Termination w.r.t. Q proof of /tmp/tmp-NJI9I/qsortmiddle.trs

Termination w.r.t. Q of the following Term Rewriting System could be proven:

Q restricted rewrite system:
The TRS R consists of the following rules:

qsort(xs) → qs(half(length(xs)), xs)
qs(n, nil) → nil
qs(n, cons(x, xs)) → append(qs(half(n), filterlow(get(n, cons(x, xs)), cons(x, xs))), cons(get(n, cons(x, xs)), qs(half(n), filterhigh(get(n, cons(x, xs)), cons(x, xs)))))
filterlow(n, nil) → nil
filterlow(n, cons(x, xs)) → if1(ge(n, x), n, x, xs)
if1(true, n, x, xs) → filterlow(n, xs)
if1(false, n, x, xs) → cons(x, filterlow(n, xs))
filterhigh(n, nil) → nil
filterhigh(n, cons(x, xs)) → if2(ge(x, n), n, x, xs)
if2(true, n, x, xs) → filterhigh(n, xs)
if2(false, n, x, xs) → cons(x, filterhigh(n, xs))
ge(x, 0) → true
ge(0, s(x)) → false
ge(s(x), s(y)) → ge(x, y)
append(nil, ys) → ys
append(cons(x, xs), ys) → cons(x, append(xs, ys))
length(nil) → 0
length(cons(x, xs)) → s(length(xs))
half(0) → 0
half(s(0)) → 0
half(s(s(x))) → s(half(x))
get(n, nil) → 0
get(n, cons(x, nil)) → x
get(0, cons(x, cons(y, xs))) → x
get(s(n), cons(x, cons(y, xs))) → get(n, cons(y, xs))

Q is empty.

↳ QTRS

  ↳ Overlay + Local Confluence

Q restricted rewrite system:
The TRS R consists of the following rules:

qsort(xs) → qs(half(length(xs)), xs)
qs(n, nil) → nil
qs(n, cons(x, xs)) → append(qs(half(n), filterlow(get(n, cons(x, xs)), cons(x, xs))), cons(get(n, cons(x, xs)), qs(half(n), filterhigh(get(n, cons(x, xs)), cons(x, xs)))))
filterlow(n, nil) → nil
filterlow(n, cons(x, xs)) → if1(ge(n, x), n, x, xs)
if1(true, n, x, xs) → filterlow(n, xs)
if1(false, n, x, xs) → cons(x, filterlow(n, xs))
filterhigh(n, nil) → nil
filterhigh(n, cons(x, xs)) → if2(ge(x, n), n, x, xs)
if2(true, n, x, xs) → filterhigh(n, xs)
if2(false, n, x, xs) → cons(x, filterhigh(n, xs))
ge(x, 0) → true
ge(0, s(x)) → false
ge(s(x), s(y)) → ge(x, y)
append(nil, ys) → ys
append(cons(x, xs), ys) → cons(x, append(xs, ys))
length(nil) → 0
length(cons(x, xs)) → s(length(xs))
half(0) → 0
half(s(0)) → 0
half(s(s(x))) → s(half(x))
get(n, nil) → 0
get(n, cons(x, nil)) → x
get(0, cons(x, cons(y, xs))) → x
get(s(n), cons(x, cons(y, xs))) → get(n, cons(y, xs))

Q is empty.

The TRS is overlay and locally confluent. By [NOC] we can switch to innermost.

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

Q restricted rewrite system:
The TRS R consists of the following rules:

qsort(xs) → qs(half(length(xs)), xs)
qs(n, nil) → nil
qs(n, cons(x, xs)) → append(qs(half(n), filterlow(get(n, cons(x, xs)), cons(x, xs))), cons(get(n, cons(x, xs)), qs(half(n), filterhigh(get(n, cons(x, xs)), cons(x, xs)))))
filterlow(n, nil) → nil
filterlow(n, cons(x, xs)) → if1(ge(n, x), n, x, xs)
if1(true, n, x, xs) → filterlow(n, xs)
if1(false, n, x, xs) → cons(x, filterlow(n, xs))
filterhigh(n, nil) → nil
filterhigh(n, cons(x, xs)) → if2(ge(x, n), n, x, xs)
if2(true, n, x, xs) → filterhigh(n, xs)
if2(false, n, x, xs) → cons(x, filterhigh(n, xs))
ge(x, 0) → true
ge(0, s(x)) → false
ge(s(x), s(y)) → ge(x, y)
append(nil, ys) → ys
append(cons(x, xs), ys) → cons(x, append(xs, ys))
length(nil) → 0
length(cons(x, xs)) → s(length(xs))
half(0) → 0
half(s(0)) → 0
half(s(s(x))) → s(half(x))
get(n, nil) → 0
get(n, cons(x, nil)) → x
get(0, cons(x, cons(y, xs))) → x
get(s(n), cons(x, cons(y, xs))) → get(n, cons(y, xs))

The set Q consists of the following terms:

qsort(x0)
qs(x0, nil)
qs(x0, cons(x1, x2))
filterlow(x0, nil)
filterlow(x0, cons(x1, x2))
if1(true, x0, x1, x2)
if1(false, x0, x1, x2)
filterhigh(x0, nil)
filterhigh(x0, cons(x1, x2))
if2(true, x0, x1, x2)
if2(false, x0, x1, x2)
ge(x0, 0)
ge(0, s(x0))
ge(s(x0), s(x1))
append(nil, ys)
append(cons(x0, x1), ys)
length(nil)
length(cons(x0, x1))
half(0)
half(s(0))
half(s(s(x0)))
get(x0, nil)
get(x0, cons(x1, nil))
get(0, cons(x0, cons(x1, x2)))
get(s(x0), cons(x1, cons(x2, x3)))

Using Dependency Pairs [AG00,LPAR04] we result in the following initial DP problem:
Q DP problem:
The TRS P consists of the following rules:

QSORT(xs) → QS(half(length(xs)), xs)
QSORT(xs) → HALF(length(xs))
QSORT(xs) → LENGTH(xs)
QS(n, cons(x, xs)) → APPEND(qs(half(n), filterlow(get(n, cons(x, xs)), cons(x, xs))), cons(get(n, cons(x, xs)), qs(half(n), filterhigh(get(n, cons(x, xs)), cons(x, xs)))))
QS(n, cons(x, xs)) → QS(half(n), filterlow(get(n, cons(x, xs)), cons(x, xs)))
QS(n, cons(x, xs)) → HALF(n)
QS(n, cons(x, xs)) → FILTERLOW(get(n, cons(x, xs)), cons(x, xs))
QS(n, cons(x, xs)) → GET(n, cons(x, xs))
QS(n, cons(x, xs)) → QS(half(n), filterhigh(get(n, cons(x, xs)), cons(x, xs)))
QS(n, cons(x, xs)) → FILTERHIGH(get(n, cons(x, xs)), cons(x, xs))
FILTERLOW(n, cons(x, xs)) → IF1(ge(n, x), n, x, xs)
FILTERLOW(n, cons(x, xs)) → GE(n, x)
IF1(true, n, x, xs) → FILTERLOW(n, xs)
IF1(false, n, x, xs) → FILTERLOW(n, xs)
FILTERHIGH(n, cons(x, xs)) → IF2(ge(x, n), n, x, xs)
FILTERHIGH(n, cons(x, xs)) → GE(x, n)
IF2(true, n, x, xs) → FILTERHIGH(n, xs)
IF2(false, n, x, xs) → FILTERHIGH(n, xs)
GE(s(x), s(y)) → GE(x, y)
APPEND(cons(x, xs), ys) → APPEND(xs, ys)
LENGTH(cons(x, xs)) → LENGTH(xs)
HALF(s(s(x))) → HALF(x)
GET(s(n), cons(x, cons(y, xs))) → GET(n, cons(y, xs))

The TRS R consists of the following rules:

qsort(xs) → qs(half(length(xs)), xs)
qs(n, nil) → nil
qs(n, cons(x, xs)) → append(qs(half(n), filterlow(get(n, cons(x, xs)), cons(x, xs))), cons(get(n, cons(x, xs)), qs(half(n), filterhigh(get(n, cons(x, xs)), cons(x, xs)))))
filterlow(n, nil) → nil
filterlow(n, cons(x, xs)) → if1(ge(n, x), n, x, xs)
if1(true, n, x, xs) → filterlow(n, xs)
if1(false, n, x, xs) → cons(x, filterlow(n, xs))
filterhigh(n, nil) → nil
filterhigh(n, cons(x, xs)) → if2(ge(x, n), n, x, xs)
if2(true, n, x, xs) → filterhigh(n, xs)
if2(false, n, x, xs) → cons(x, filterhigh(n, xs))
ge(x, 0) → true
ge(0, s(x)) → false
ge(s(x), s(y)) → ge(x, y)
append(nil, ys) → ys
append(cons(x, xs), ys) → cons(x, append(xs, ys))
length(nil) → 0
length(cons(x, xs)) → s(length(xs))
half(0) → 0
half(s(0)) → 0
half(s(s(x))) → s(half(x))
get(n, nil) → 0
get(n, cons(x, nil)) → x
get(0, cons(x, cons(y, xs))) → x
get(s(n), cons(x, cons(y, xs))) → get(n, cons(y, xs))

The set Q consists of the following terms:

qsort(x0)
qs(x0, nil)
qs(x0, cons(x1, x2))
filterlow(x0, nil)
filterlow(x0, cons(x1, x2))
if1(true, x0, x1, x2)
if1(false, x0, x1, x2)
filterhigh(x0, nil)
filterhigh(x0, cons(x1, x2))
if2(true, x0, x1, x2)
if2(false, x0, x1, x2)
ge(x0, 0)
ge(0, s(x0))
ge(s(x0), s(x1))
append(nil, ys)
append(cons(x0, x1), ys)
length(nil)
length(cons(x0, x1))
half(0)
half(s(0))
half(s(s(x0)))
get(x0, nil)
get(x0, cons(x1, nil))
get(0, cons(x0, cons(x1, x2)))
get(s(x0), cons(x1, cons(x2, x3)))

We have to consider all minimal (P,Q,R)-chains.

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

QSORT(xs) → QS(half(length(xs)), xs)
QSORT(xs) → HALF(length(xs))
QSORT(xs) → LENGTH(xs)
QS(n, cons(x, xs)) → APPEND(qs(half(n), filterlow(get(n, cons(x, xs)), cons(x, xs))), cons(get(n, cons(x, xs)), qs(half(n), filterhigh(get(n, cons(x, xs)), cons(x, xs)))))
QS(n, cons(x, xs)) → QS(half(n), filterlow(get(n, cons(x, xs)), cons(x, xs)))
QS(n, cons(x, xs)) → HALF(n)
QS(n, cons(x, xs)) → FILTERLOW(get(n, cons(x, xs)), cons(x, xs))
QS(n, cons(x, xs)) → GET(n, cons(x, xs))
QS(n, cons(x, xs)) → QS(half(n), filterhigh(get(n, cons(x, xs)), cons(x, xs)))
QS(n, cons(x, xs)) → FILTERHIGH(get(n, cons(x, xs)), cons(x, xs))
FILTERLOW(n, cons(x, xs)) → IF1(ge(n, x), n, x, xs)
FILTERLOW(n, cons(x, xs)) → GE(n, x)
IF1(true, n, x, xs) → FILTERLOW(n, xs)
IF1(false, n, x, xs) → FILTERLOW(n, xs)
FILTERHIGH(n, cons(x, xs)) → IF2(ge(x, n), n, x, xs)
FILTERHIGH(n, cons(x, xs)) → GE(x, n)
IF2(true, n, x, xs) → FILTERHIGH(n, xs)
IF2(false, n, x, xs) → FILTERHIGH(n, xs)
GE(s(x), s(y)) → GE(x, y)
APPEND(cons(x, xs), ys) → APPEND(xs, ys)
LENGTH(cons(x, xs)) → LENGTH(xs)
HALF(s(s(x))) → HALF(x)
GET(s(n), cons(x, cons(y, xs))) → GET(n, cons(y, xs))

The TRS R consists of the following rules:

qsort(xs) → qs(half(length(xs)), xs)
qs(n, nil) → nil
qs(n, cons(x, xs)) → append(qs(half(n), filterlow(get(n, cons(x, xs)), cons(x, xs))), cons(get(n, cons(x, xs)), qs(half(n), filterhigh(get(n, cons(x, xs)), cons(x, xs)))))
filterlow(n, nil) → nil
filterlow(n, cons(x, xs)) → if1(ge(n, x), n, x, xs)
if1(true, n, x, xs) → filterlow(n, xs)
if1(false, n, x, xs) → cons(x, filterlow(n, xs))
filterhigh(n, nil) → nil
filterhigh(n, cons(x, xs)) → if2(ge(x, n), n, x, xs)
if2(true, n, x, xs) → filterhigh(n, xs)
if2(false, n, x, xs) → cons(x, filterhigh(n, xs))
ge(x, 0) → true
ge(0, s(x)) → false
ge(s(x), s(y)) → ge(x, y)
append(nil, ys) → ys
append(cons(x, xs), ys) → cons(x, append(xs, ys))
length(nil) → 0
length(cons(x, xs)) → s(length(xs))
half(0) → 0
half(s(0)) → 0
half(s(s(x))) → s(half(x))
get(n, nil) → 0
get(n, cons(x, nil)) → x
get(0, cons(x, cons(y, xs))) → x
get(s(n), cons(x, cons(y, xs))) → get(n, cons(y, xs))

The set Q consists of the following terms:

qsort(x0)
qs(x0, nil)
qs(x0, cons(x1, x2))
filterlow(x0, nil)
filterlow(x0, cons(x1, x2))
if1(true, x0, x1, x2)
if1(false, x0, x1, x2)
filterhigh(x0, nil)
filterhigh(x0, cons(x1, x2))
if2(true, x0, x1, x2)
if2(false, x0, x1, x2)
ge(x0, 0)
ge(0, s(x0))
ge(s(x0), s(x1))
append(nil, ys)
append(cons(x0, x1), ys)
length(nil)
length(cons(x0, x1))
half(0)
half(s(0))
half(s(s(x0)))
get(x0, nil)
get(x0, cons(x1, nil))
get(0, cons(x0, cons(x1, x2)))
get(s(x0), cons(x1, cons(x2, x3)))

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 8 SCCs with 10 less nodes.

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

                ↳ UsableRulesProof

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

GET(s(n), cons(x, cons(y, xs))) → GET(n, cons(y, xs))

The TRS R consists of the following rules:

qsort(xs) → qs(half(length(xs)), xs)
qs(n, nil) → nil
qs(n, cons(x, xs)) → append(qs(half(n), filterlow(get(n, cons(x, xs)), cons(x, xs))), cons(get(n, cons(x, xs)), qs(half(n), filterhigh(get(n, cons(x, xs)), cons(x, xs)))))
filterlow(n, nil) → nil
filterlow(n, cons(x, xs)) → if1(ge(n, x), n, x, xs)
if1(true, n, x, xs) → filterlow(n, xs)
if1(false, n, x, xs) → cons(x, filterlow(n, xs))
filterhigh(n, nil) → nil
filterhigh(n, cons(x, xs)) → if2(ge(x, n), n, x, xs)
if2(true, n, x, xs) → filterhigh(n, xs)
if2(false, n, x, xs) → cons(x, filterhigh(n, xs))
ge(x, 0) → true
ge(0, s(x)) → false
ge(s(x), s(y)) → ge(x, y)
append(nil, ys) → ys
append(cons(x, xs), ys) → cons(x, append(xs, ys))
length(nil) → 0
length(cons(x, xs)) → s(length(xs))
half(0) → 0
half(s(0)) → 0
half(s(s(x))) → s(half(x))
get(n, nil) → 0
get(n, cons(x, nil)) → x
get(0, cons(x, cons(y, xs))) → x
get(s(n), cons(x, cons(y, xs))) → get(n, cons(y, xs))

The set Q consists of the following terms:

qsort(x0)
qs(x0, nil)
qs(x0, cons(x1, x2))
filterlow(x0, nil)
filterlow(x0, cons(x1, x2))
if1(true, x0, x1, x2)
if1(false, x0, x1, x2)
filterhigh(x0, nil)
filterhigh(x0, cons(x1, x2))
if2(true, x0, x1, x2)
if2(false, x0, x1, x2)
ge(x0, 0)
ge(0, s(x0))
ge(s(x0), s(x1))
append(nil, ys)
append(cons(x0, x1), ys)
length(nil)
length(cons(x0, x1))
half(0)
half(s(0))
half(s(s(x0)))
get(x0, nil)
get(x0, cons(x1, nil))
get(0, cons(x0, cons(x1, x2)))
get(s(x0), cons(x1, cons(x2, x3)))

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R.

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

GET(s(n), cons(x, cons(y, xs))) → GET(n, cons(y, xs))

R is empty.
The set Q consists of the following terms:

qsort(x0)
qs(x0, nil)
qs(x0, cons(x1, x2))
filterlow(x0, nil)
filterlow(x0, cons(x1, x2))
if1(true, x0, x1, x2)
if1(false, x0, x1, x2)
filterhigh(x0, nil)
filterhigh(x0, cons(x1, x2))
if2(true, x0, x1, x2)
if2(false, x0, x1, x2)
ge(x0, 0)
ge(0, s(x0))
ge(s(x0), s(x1))
append(nil, ys)
append(cons(x0, x1), ys)
length(nil)
length(cons(x0, x1))
half(0)
half(s(0))
half(s(s(x0)))
get(x0, nil)
get(x0, cons(x1, nil))
get(0, cons(x0, cons(x1, x2)))
get(s(x0), cons(x1, cons(x2, x3)))

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN].

qsort(x0)
qs(x0, nil)
qs(x0, cons(x1, x2))
filterlow(x0, nil)
filterlow(x0, cons(x1, x2))
if1(true, x0, x1, x2)
if1(false, x0, x1, x2)
filterhigh(x0, nil)
filterhigh(x0, cons(x1, x2))
if2(true, x0, x1, x2)
if2(false, x0, x1, x2)
ge(x0, 0)
ge(0, s(x0))
ge(s(x0), s(x1))
append(nil, ys)
append(cons(x0, x1), ys)
length(nil)
length(cons(x0, x1))
half(0)
half(s(0))
half(s(s(x0)))
get(x0, nil)
get(x0, cons(x1, nil))
get(0, cons(x0, cons(x1, x2)))
get(s(x0), cons(x1, cons(x2, x3)))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ QDPSizeChangeProof

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

GET(s(n), cons(x, cons(y, xs))) → GET(n, cons(y, xs))

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [SUBTERM_CRITERION] together with the size-change analysis [AAECC05] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:

GET(s(n), cons(x, cons(y, xs))) → GET(n, cons(y, xs))
The graph contains the following edges 1 > 1, 2 > 2

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

HALF(s(s(x))) → HALF(x)

The TRS R consists of the following rules:

qsort(xs) → qs(half(length(xs)), xs)
qs(n, nil) → nil
qs(n, cons(x, xs)) → append(qs(half(n), filterlow(get(n, cons(x, xs)), cons(x, xs))), cons(get(n, cons(x, xs)), qs(half(n), filterhigh(get(n, cons(x, xs)), cons(x, xs)))))
filterlow(n, nil) → nil
filterlow(n, cons(x, xs)) → if1(ge(n, x), n, x, xs)
if1(true, n, x, xs) → filterlow(n, xs)
if1(false, n, x, xs) → cons(x, filterlow(n, xs))
filterhigh(n, nil) → nil
filterhigh(n, cons(x, xs)) → if2(ge(x, n), n, x, xs)
if2(true, n, x, xs) → filterhigh(n, xs)
if2(false, n, x, xs) → cons(x, filterhigh(n, xs))
ge(x, 0) → true
ge(0, s(x)) → false
ge(s(x), s(y)) → ge(x, y)
append(nil, ys) → ys
append(cons(x, xs), ys) → cons(x, append(xs, ys))
length(nil) → 0
length(cons(x, xs)) → s(length(xs))
half(0) → 0
half(s(0)) → 0
half(s(s(x))) → s(half(x))
get(n, nil) → 0
get(n, cons(x, nil)) → x
get(0, cons(x, cons(y, xs))) → x
get(s(n), cons(x, cons(y, xs))) → get(n, cons(y, xs))

The set Q consists of the following terms:

qsort(x0)
qs(x0, nil)
qs(x0, cons(x1, x2))
filterlow(x0, nil)
filterlow(x0, cons(x1, x2))
if1(true, x0, x1, x2)
if1(false, x0, x1, x2)
filterhigh(x0, nil)
filterhigh(x0, cons(x1, x2))
if2(true, x0, x1, x2)
if2(false, x0, x1, x2)
ge(x0, 0)
ge(0, s(x0))
ge(s(x0), s(x1))
append(nil, ys)
append(cons(x0, x1), ys)
length(nil)
length(cons(x0, x1))
half(0)
half(s(0))
half(s(s(x0)))
get(x0, nil)
get(x0, cons(x1, nil))
get(0, cons(x0, cons(x1, x2)))
get(s(x0), cons(x1, cons(x2, x3)))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

HALF(s(s(x))) → HALF(x)

R is empty.
The set Q consists of the following terms:

qsort(x0)
qs(x0, nil)
qs(x0, cons(x1, x2))
filterlow(x0, nil)
filterlow(x0, cons(x1, x2))
if1(true, x0, x1, x2)
if1(false, x0, x1, x2)
filterhigh(x0, nil)
filterhigh(x0, cons(x1, x2))
if2(true, x0, x1, x2)
if2(false, x0, x1, x2)
ge(x0, 0)
ge(0, s(x0))
ge(s(x0), s(x1))
append(nil, ys)
append(cons(x0, x1), ys)
length(nil)
length(cons(x0, x1))
half(0)
half(s(0))
half(s(s(x0)))
get(x0, nil)
get(x0, cons(x1, nil))
get(0, cons(x0, cons(x1, x2)))
get(s(x0), cons(x1, cons(x2, x3)))

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN].

qsort(x0)
qs(x0, nil)
qs(x0, cons(x1, x2))
filterlow(x0, nil)
filterlow(x0, cons(x1, x2))
if1(true, x0, x1, x2)
if1(false, x0, x1, x2)
filterhigh(x0, nil)
filterhigh(x0, cons(x1, x2))
if2(true, x0, x1, x2)
if2(false, x0, x1, x2)
ge(x0, 0)
ge(0, s(x0))
ge(s(x0), s(x1))
append(nil, ys)
append(cons(x0, x1), ys)
length(nil)
length(cons(x0, x1))
half(0)
half(s(0))
half(s(s(x0)))
get(x0, nil)
get(x0, cons(x1, nil))
get(0, cons(x0, cons(x1, x2)))
get(s(x0), cons(x1, cons(x2, x3)))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ QDPSizeChangeProof

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

HALF(s(s(x))) → HALF(x)

From the DPs we obtained the following set of size-change graphs:

HALF(s(s(x))) → HALF(x)
The graph contains the following edges 1 > 1

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

LENGTH(cons(x, xs)) → LENGTH(xs)

The TRS R consists of the following rules:

qsort(xs) → qs(half(length(xs)), xs)
qs(n, nil) → nil
qs(n, cons(x, xs)) → append(qs(half(n), filterlow(get(n, cons(x, xs)), cons(x, xs))), cons(get(n, cons(x, xs)), qs(half(n), filterhigh(get(n, cons(x, xs)), cons(x, xs)))))
filterlow(n, nil) → nil
filterlow(n, cons(x, xs)) → if1(ge(n, x), n, x, xs)
if1(true, n, x, xs) → filterlow(n, xs)
if1(false, n, x, xs) → cons(x, filterlow(n, xs))
filterhigh(n, nil) → nil
filterhigh(n, cons(x, xs)) → if2(ge(x, n), n, x, xs)
if2(true, n, x, xs) → filterhigh(n, xs)
if2(false, n, x, xs) → cons(x, filterhigh(n, xs))
ge(x, 0) → true
ge(0, s(x)) → false
ge(s(x), s(y)) → ge(x, y)
append(nil, ys) → ys
append(cons(x, xs), ys) → cons(x, append(xs, ys))
length(nil) → 0
length(cons(x, xs)) → s(length(xs))
half(0) → 0
half(s(0)) → 0
half(s(s(x))) → s(half(x))
get(n, nil) → 0
get(n, cons(x, nil)) → x
get(0, cons(x, cons(y, xs))) → x
get(s(n), cons(x, cons(y, xs))) → get(n, cons(y, xs))

The set Q consists of the following terms:

qsort(x0)
qs(x0, nil)
qs(x0, cons(x1, x2))
filterlow(x0, nil)
filterlow(x0, cons(x1, x2))
if1(true, x0, x1, x2)
if1(false, x0, x1, x2)
filterhigh(x0, nil)
filterhigh(x0, cons(x1, x2))
if2(true, x0, x1, x2)
if2(false, x0, x1, x2)
ge(x0, 0)
ge(0, s(x0))
ge(s(x0), s(x1))
append(nil, ys)
append(cons(x0, x1), ys)
length(nil)
length(cons(x0, x1))
half(0)
half(s(0))
half(s(s(x0)))
get(x0, nil)
get(x0, cons(x1, nil))
get(0, cons(x0, cons(x1, x2)))
get(s(x0), cons(x1, cons(x2, x3)))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

LENGTH(cons(x, xs)) → LENGTH(xs)

R is empty.
The set Q consists of the following terms:

qsort(x0)
qs(x0, nil)
qs(x0, cons(x1, x2))
filterlow(x0, nil)
filterlow(x0, cons(x1, x2))
if1(true, x0, x1, x2)
if1(false, x0, x1, x2)
filterhigh(x0, nil)
filterhigh(x0, cons(x1, x2))
if2(true, x0, x1, x2)
if2(false, x0, x1, x2)
ge(x0, 0)
ge(0, s(x0))
ge(s(x0), s(x1))
append(nil, ys)
append(cons(x0, x1), ys)
length(nil)
length(cons(x0, x1))
half(0)
half(s(0))
half(s(s(x0)))
get(x0, nil)
get(x0, cons(x1, nil))
get(0, cons(x0, cons(x1, x2)))
get(s(x0), cons(x1, cons(x2, x3)))

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN].

qsort(x0)
qs(x0, nil)
qs(x0, cons(x1, x2))
filterlow(x0, nil)
filterlow(x0, cons(x1, x2))
if1(true, x0, x1, x2)
if1(false, x0, x1, x2)
filterhigh(x0, nil)
filterhigh(x0, cons(x1, x2))
if2(true, x0, x1, x2)
if2(false, x0, x1, x2)
ge(x0, 0)
ge(0, s(x0))
ge(s(x0), s(x1))
append(nil, ys)
append(cons(x0, x1), ys)
length(nil)
length(cons(x0, x1))
half(0)
half(s(0))
half(s(s(x0)))
get(x0, nil)
get(x0, cons(x1, nil))
get(0, cons(x0, cons(x1, x2)))
get(s(x0), cons(x1, cons(x2, x3)))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ QDPSizeChangeProof

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

LENGTH(cons(x, xs)) → LENGTH(xs)

From the DPs we obtained the following set of size-change graphs:

LENGTH(cons(x, xs)) → LENGTH(xs)
The graph contains the following edges 1 > 1

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

APPEND(cons(x, xs), ys) → APPEND(xs, ys)

The TRS R consists of the following rules:

qsort(xs) → qs(half(length(xs)), xs)
qs(n, nil) → nil
qs(n, cons(x, xs)) → append(qs(half(n), filterlow(get(n, cons(x, xs)), cons(x, xs))), cons(get(n, cons(x, xs)), qs(half(n), filterhigh(get(n, cons(x, xs)), cons(x, xs)))))
filterlow(n, nil) → nil
filterlow(n, cons(x, xs)) → if1(ge(n, x), n, x, xs)
if1(true, n, x, xs) → filterlow(n, xs)
if1(false, n, x, xs) → cons(x, filterlow(n, xs))
filterhigh(n, nil) → nil
filterhigh(n, cons(x, xs)) → if2(ge(x, n), n, x, xs)
if2(true, n, x, xs) → filterhigh(n, xs)
if2(false, n, x, xs) → cons(x, filterhigh(n, xs))
ge(x, 0) → true
ge(0, s(x)) → false
ge(s(x), s(y)) → ge(x, y)
append(nil, ys) → ys
append(cons(x, xs), ys) → cons(x, append(xs, ys))
length(nil) → 0
length(cons(x, xs)) → s(length(xs))
half(0) → 0
half(s(0)) → 0
half(s(s(x))) → s(half(x))
get(n, nil) → 0
get(n, cons(x, nil)) → x
get(0, cons(x, cons(y, xs))) → x
get(s(n), cons(x, cons(y, xs))) → get(n, cons(y, xs))

The set Q consists of the following terms:

qsort(x0)
qs(x0, nil)
qs(x0, cons(x1, x2))
filterlow(x0, nil)
filterlow(x0, cons(x1, x2))
if1(true, x0, x1, x2)
if1(false, x0, x1, x2)
filterhigh(x0, nil)
filterhigh(x0, cons(x1, x2))
if2(true, x0, x1, x2)
if2(false, x0, x1, x2)
ge(x0, 0)
ge(0, s(x0))
ge(s(x0), s(x1))
append(nil, ys)
append(cons(x0, x1), ys)
length(nil)
length(cons(x0, x1))
half(0)
half(s(0))
half(s(s(x0)))
get(x0, nil)
get(x0, cons(x1, nil))
get(0, cons(x0, cons(x1, x2)))
get(s(x0), cons(x1, cons(x2, x3)))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

APPEND(cons(x, xs), ys) → APPEND(xs, ys)

R is empty.
The set Q consists of the following terms:

qsort(x0)
qs(x0, nil)
qs(x0, cons(x1, x2))
filterlow(x0, nil)
filterlow(x0, cons(x1, x2))
if1(true, x0, x1, x2)
if1(false, x0, x1, x2)
filterhigh(x0, nil)
filterhigh(x0, cons(x1, x2))
if2(true, x0, x1, x2)
if2(false, x0, x1, x2)
ge(x0, 0)
ge(0, s(x0))
ge(s(x0), s(x1))
append(nil, ys)
append(cons(x0, x1), ys)
length(nil)
length(cons(x0, x1))
half(0)
half(s(0))
half(s(s(x0)))
get(x0, nil)
get(x0, cons(x1, nil))
get(0, cons(x0, cons(x1, x2)))
get(s(x0), cons(x1, cons(x2, x3)))

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN].

qsort(x0)
qs(x0, nil)
qs(x0, cons(x1, x2))
filterlow(x0, nil)
filterlow(x0, cons(x1, x2))
if1(true, x0, x1, x2)
if1(false, x0, x1, x2)
filterhigh(x0, nil)
filterhigh(x0, cons(x1, x2))
if2(true, x0, x1, x2)
if2(false, x0, x1, x2)
ge(x0, 0)
ge(0, s(x0))
ge(s(x0), s(x1))
append(nil, ys)
append(cons(x0, x1), ys)
length(nil)
length(cons(x0, x1))
half(0)
half(s(0))
half(s(s(x0)))
get(x0, nil)
get(x0, cons(x1, nil))
get(0, cons(x0, cons(x1, x2)))
get(s(x0), cons(x1, cons(x2, x3)))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ QDPSizeChangeProof

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

APPEND(cons(x, xs), ys) → APPEND(xs, ys)

From the DPs we obtained the following set of size-change graphs:

APPEND(cons(x, xs), ys) → APPEND(xs, ys)
The graph contains the following edges 1 > 1, 2 >= 2

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

              ↳ QDP

              ↳ QDP

              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

GE(s(x), s(y)) → GE(x, y)

The TRS R consists of the following rules:

qsort(xs) → qs(half(length(xs)), xs)
qs(n, nil) → nil
qs(n, cons(x, xs)) → append(qs(half(n), filterlow(get(n, cons(x, xs)), cons(x, xs))), cons(get(n, cons(x, xs)), qs(half(n), filterhigh(get(n, cons(x, xs)), cons(x, xs)))))
filterlow(n, nil) → nil
filterlow(n, cons(x, xs)) → if1(ge(n, x), n, x, xs)
if1(true, n, x, xs) → filterlow(n, xs)
if1(false, n, x, xs) → cons(x, filterlow(n, xs))
filterhigh(n, nil) → nil
filterhigh(n, cons(x, xs)) → if2(ge(x, n), n, x, xs)
if2(true, n, x, xs) → filterhigh(n, xs)
if2(false, n, x, xs) → cons(x, filterhigh(n, xs))
ge(x, 0) → true
ge(0, s(x)) → false
ge(s(x), s(y)) → ge(x, y)
append(nil, ys) → ys
append(cons(x, xs), ys) → cons(x, append(xs, ys))
length(nil) → 0
length(cons(x, xs)) → s(length(xs))
half(0) → 0
half(s(0)) → 0
half(s(s(x))) → s(half(x))
get(n, nil) → 0
get(n, cons(x, nil)) → x
get(0, cons(x, cons(y, xs))) → x
get(s(n), cons(x, cons(y, xs))) → get(n, cons(y, xs))

The set Q consists of the following terms:

qsort(x0)
qs(x0, nil)
qs(x0, cons(x1, x2))
filterlow(x0, nil)
filterlow(x0, cons(x1, x2))
if1(true, x0, x1, x2)
if1(false, x0, x1, x2)
filterhigh(x0, nil)
filterhigh(x0, cons(x1, x2))
if2(true, x0, x1, x2)
if2(false, x0, x1, x2)
ge(x0, 0)
ge(0, s(x0))
ge(s(x0), s(x1))
append(nil, ys)
append(cons(x0, x1), ys)
length(nil)
length(cons(x0, x1))
half(0)
half(s(0))
half(s(s(x0)))
get(x0, nil)
get(x0, cons(x1, nil))
get(0, cons(x0, cons(x1, x2)))
get(s(x0), cons(x1, cons(x2, x3)))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

              ↳ QDP

              ↳ QDP

              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

GE(s(x), s(y)) → GE(x, y)

R is empty.
The set Q consists of the following terms:

qsort(x0)
qs(x0, nil)
qs(x0, cons(x1, x2))
filterlow(x0, nil)
filterlow(x0, cons(x1, x2))
if1(true, x0, x1, x2)
if1(false, x0, x1, x2)
filterhigh(x0, nil)
filterhigh(x0, cons(x1, x2))
if2(true, x0, x1, x2)
if2(false, x0, x1, x2)
ge(x0, 0)
ge(0, s(x0))
ge(s(x0), s(x1))
append(nil, ys)
append(cons(x0, x1), ys)
length(nil)
length(cons(x0, x1))
half(0)
half(s(0))
half(s(s(x0)))
get(x0, nil)
get(x0, cons(x1, nil))
get(0, cons(x0, cons(x1, x2)))
get(s(x0), cons(x1, cons(x2, x3)))

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN].

qsort(x0)
qs(x0, nil)
qs(x0, cons(x1, x2))
filterlow(x0, nil)
filterlow(x0, cons(x1, x2))
if1(true, x0, x1, x2)
if1(false, x0, x1, x2)
filterhigh(x0, nil)
filterhigh(x0, cons(x1, x2))
if2(true, x0, x1, x2)
if2(false, x0, x1, x2)
ge(x0, 0)
ge(0, s(x0))
ge(s(x0), s(x1))
append(nil, ys)
append(cons(x0, x1), ys)
length(nil)
length(cons(x0, x1))
half(0)
half(s(0))
half(s(s(x0)))
get(x0, nil)
get(x0, cons(x1, nil))
get(0, cons(x0, cons(x1, x2)))
get(s(x0), cons(x1, cons(x2, x3)))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ QDPSizeChangeProof

              ↳ QDP

              ↳ QDP

              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

GE(s(x), s(y)) → GE(x, y)

From the DPs we obtained the following set of size-change graphs:

GE(s(x), s(y)) → GE(x, y)
The graph contains the following edges 1 > 1, 2 > 2

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

              ↳ QDP

              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

IF2(true, n, x, xs) → FILTERHIGH(n, xs)
FILTERHIGH(n, cons(x, xs)) → IF2(ge(x, n), n, x, xs)
IF2(false, n, x, xs) → FILTERHIGH(n, xs)

The TRS R consists of the following rules:

qsort(xs) → qs(half(length(xs)), xs)
qs(n, nil) → nil
qs(n, cons(x, xs)) → append(qs(half(n), filterlow(get(n, cons(x, xs)), cons(x, xs))), cons(get(n, cons(x, xs)), qs(half(n), filterhigh(get(n, cons(x, xs)), cons(x, xs)))))
filterlow(n, nil) → nil
filterlow(n, cons(x, xs)) → if1(ge(n, x), n, x, xs)
if1(true, n, x, xs) → filterlow(n, xs)
if1(false, n, x, xs) → cons(x, filterlow(n, xs))
filterhigh(n, nil) → nil
filterhigh(n, cons(x, xs)) → if2(ge(x, n), n, x, xs)
if2(true, n, x, xs) → filterhigh(n, xs)
if2(false, n, x, xs) → cons(x, filterhigh(n, xs))
ge(x, 0) → true
ge(0, s(x)) → false
ge(s(x), s(y)) → ge(x, y)
append(nil, ys) → ys
append(cons(x, xs), ys) → cons(x, append(xs, ys))
length(nil) → 0
length(cons(x, xs)) → s(length(xs))
half(0) → 0
half(s(0)) → 0
half(s(s(x))) → s(half(x))
get(n, nil) → 0
get(n, cons(x, nil)) → x
get(0, cons(x, cons(y, xs))) → x
get(s(n), cons(x, cons(y, xs))) → get(n, cons(y, xs))

The set Q consists of the following terms:

qsort(x0)
qs(x0, nil)
qs(x0, cons(x1, x2))
filterlow(x0, nil)
filterlow(x0, cons(x1, x2))
if1(true, x0, x1, x2)
if1(false, x0, x1, x2)
filterhigh(x0, nil)
filterhigh(x0, cons(x1, x2))
if2(true, x0, x1, x2)
if2(false, x0, x1, x2)
ge(x0, 0)
ge(0, s(x0))
ge(s(x0), s(x1))
append(nil, ys)
append(cons(x0, x1), ys)
length(nil)
length(cons(x0, x1))
half(0)
half(s(0))
half(s(s(x0)))
get(x0, nil)
get(x0, cons(x1, nil))
get(0, cons(x0, cons(x1, x2)))
get(s(x0), cons(x1, cons(x2, x3)))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

              ↳ QDP

              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

IF2(true, n, x, xs) → FILTERHIGH(n, xs)
FILTERHIGH(n, cons(x, xs)) → IF2(ge(x, n), n, x, xs)
IF2(false, n, x, xs) → FILTERHIGH(n, xs)

The TRS R consists of the following rules:

ge(x, 0) → true
ge(0, s(x)) → false
ge(s(x), s(y)) → ge(x, y)

The set Q consists of the following terms:

qsort(x0)
qs(x0, nil)
qs(x0, cons(x1, x2))
filterlow(x0, nil)
filterlow(x0, cons(x1, x2))
if1(true, x0, x1, x2)
if1(false, x0, x1, x2)
filterhigh(x0, nil)
filterhigh(x0, cons(x1, x2))
if2(true, x0, x1, x2)
if2(false, x0, x1, x2)
ge(x0, 0)
ge(0, s(x0))
ge(s(x0), s(x1))
append(nil, ys)
append(cons(x0, x1), ys)
length(nil)
length(cons(x0, x1))
half(0)
half(s(0))
half(s(s(x0)))
get(x0, nil)
get(x0, cons(x1, nil))
get(0, cons(x0, cons(x1, x2)))
get(s(x0), cons(x1, cons(x2, x3)))

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN].

qsort(x0)
qs(x0, nil)
qs(x0, cons(x1, x2))
filterlow(x0, nil)
filterlow(x0, cons(x1, x2))
if1(true, x0, x1, x2)
if1(false, x0, x1, x2)
filterhigh(x0, nil)
filterhigh(x0, cons(x1, x2))
if2(true, x0, x1, x2)
if2(false, x0, x1, x2)
append(nil, ys)
append(cons(x0, x1), ys)
length(nil)
length(cons(x0, x1))
half(0)
half(s(0))
half(s(s(x0)))
get(x0, nil)
get(x0, cons(x1, nil))
get(0, cons(x0, cons(x1, x2)))
get(s(x0), cons(x1, cons(x2, x3)))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ QDPSizeChangeProof

              ↳ QDP

              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

IF2(true, n, x, xs) → FILTERHIGH(n, xs)
FILTERHIGH(n, cons(x, xs)) → IF2(ge(x, n), n, x, xs)
IF2(false, n, x, xs) → FILTERHIGH(n, xs)

The TRS R consists of the following rules:

ge(x, 0) → true
ge(0, s(x)) → false
ge(s(x), s(y)) → ge(x, y)

The set Q consists of the following terms:

ge(x0, 0)
ge(0, s(x0))
ge(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [SUBTERM_CRITERION] together with the size-change analysis [AAECC05] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:

FILTERHIGH(n, cons(x, xs)) → IF2(ge(x, n), n, x, xs)
The graph contains the following edges 1 >= 2, 2 > 3, 2 > 4
IF2(true, n, x, xs) → FILTERHIGH(n, xs)
The graph contains the following edges 2 >= 1, 4 >= 2
IF2(false, n, x, xs) → FILTERHIGH(n, xs)
The graph contains the following edges 2 >= 1, 4 >= 2

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

IF1(true, n, x, xs) → FILTERLOW(n, xs)
FILTERLOW(n, cons(x, xs)) → IF1(ge(n, x), n, x, xs)
IF1(false, n, x, xs) → FILTERLOW(n, xs)

The TRS R consists of the following rules:

qsort(xs) → qs(half(length(xs)), xs)
qs(n, nil) → nil
qs(n, cons(x, xs)) → append(qs(half(n), filterlow(get(n, cons(x, xs)), cons(x, xs))), cons(get(n, cons(x, xs)), qs(half(n), filterhigh(get(n, cons(x, xs)), cons(x, xs)))))
filterlow(n, nil) → nil
filterlow(n, cons(x, xs)) → if1(ge(n, x), n, x, xs)
if1(true, n, x, xs) → filterlow(n, xs)
if1(false, n, x, xs) → cons(x, filterlow(n, xs))
filterhigh(n, nil) → nil
filterhigh(n, cons(x, xs)) → if2(ge(x, n), n, x, xs)
if2(true, n, x, xs) → filterhigh(n, xs)
if2(false, n, x, xs) → cons(x, filterhigh(n, xs))
ge(x, 0) → true
ge(0, s(x)) → false
ge(s(x), s(y)) → ge(x, y)
append(nil, ys) → ys
append(cons(x, xs), ys) → cons(x, append(xs, ys))
length(nil) → 0
length(cons(x, xs)) → s(length(xs))
half(0) → 0
half(s(0)) → 0
half(s(s(x))) → s(half(x))
get(n, nil) → 0
get(n, cons(x, nil)) → x
get(0, cons(x, cons(y, xs))) → x
get(s(n), cons(x, cons(y, xs))) → get(n, cons(y, xs))

The set Q consists of the following terms:

qsort(x0)
qs(x0, nil)
qs(x0, cons(x1, x2))
filterlow(x0, nil)
filterlow(x0, cons(x1, x2))
if1(true, x0, x1, x2)
if1(false, x0, x1, x2)
filterhigh(x0, nil)
filterhigh(x0, cons(x1, x2))
if2(true, x0, x1, x2)
if2(false, x0, x1, x2)
ge(x0, 0)
ge(0, s(x0))
ge(s(x0), s(x1))
append(nil, ys)
append(cons(x0, x1), ys)
length(nil)
length(cons(x0, x1))
half(0)
half(s(0))
half(s(s(x0)))
get(x0, nil)
get(x0, cons(x1, nil))
get(0, cons(x0, cons(x1, x2)))
get(s(x0), cons(x1, cons(x2, x3)))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

IF1(true, n, x, xs) → FILTERLOW(n, xs)
FILTERLOW(n, cons(x, xs)) → IF1(ge(n, x), n, x, xs)
IF1(false, n, x, xs) → FILTERLOW(n, xs)

The TRS R consists of the following rules:

ge(x, 0) → true
ge(0, s(x)) → false
ge(s(x), s(y)) → ge(x, y)

The set Q consists of the following terms:

qsort(x0)
qs(x0, nil)
qs(x0, cons(x1, x2))
filterlow(x0, nil)
filterlow(x0, cons(x1, x2))
if1(true, x0, x1, x2)
if1(false, x0, x1, x2)
filterhigh(x0, nil)
filterhigh(x0, cons(x1, x2))
if2(true, x0, x1, x2)
if2(false, x0, x1, x2)
ge(x0, 0)
ge(0, s(x0))
ge(s(x0), s(x1))
append(nil, ys)
append(cons(x0, x1), ys)
length(nil)
length(cons(x0, x1))
half(0)
half(s(0))
half(s(s(x0)))
get(x0, nil)
get(x0, cons(x1, nil))
get(0, cons(x0, cons(x1, x2)))
get(s(x0), cons(x1, cons(x2, x3)))

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN].

qsort(x0)
qs(x0, nil)
qs(x0, cons(x1, x2))
filterlow(x0, nil)
filterlow(x0, cons(x1, x2))
if1(true, x0, x1, x2)
if1(false, x0, x1, x2)
filterhigh(x0, nil)
filterhigh(x0, cons(x1, x2))
if2(true, x0, x1, x2)
if2(false, x0, x1, x2)
append(nil, ys)
append(cons(x0, x1), ys)
length(nil)
length(cons(x0, x1))
half(0)
half(s(0))
half(s(s(x0)))
get(x0, nil)
get(x0, cons(x1, nil))
get(0, cons(x0, cons(x1, x2)))
get(s(x0), cons(x1, cons(x2, x3)))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ QDPSizeChangeProof

              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

IF1(true, n, x, xs) → FILTERLOW(n, xs)
FILTERLOW(n, cons(x, xs)) → IF1(ge(n, x), n, x, xs)
IF1(false, n, x, xs) → FILTERLOW(n, xs)

The TRS R consists of the following rules:

ge(x, 0) → true
ge(0, s(x)) → false
ge(s(x), s(y)) → ge(x, y)

The set Q consists of the following terms:

ge(x0, 0)
ge(0, s(x0))
ge(s(x0), s(x1))

From the DPs we obtained the following set of size-change graphs:

FILTERLOW(n, cons(x, xs)) → IF1(ge(n, x), n, x, xs)
The graph contains the following edges 1 >= 2, 2 > 3, 2 > 4
IF1(true, n, x, xs) → FILTERLOW(n, xs)
The graph contains the following edges 2 >= 1, 4 >= 2
IF1(false, n, x, xs) → FILTERLOW(n, xs)
The graph contains the following edges 2 >= 1, 4 >= 2

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

Q DP problem:
The TRS P consists of the following rules:

QS(n, cons(x, xs)) → QS(half(n), filterhigh(get(n, cons(x, xs)), cons(x, xs)))
QS(n, cons(x, xs)) → QS(half(n), filterlow(get(n, cons(x, xs)), cons(x, xs)))

The TRS R consists of the following rules:

qsort(xs) → qs(half(length(xs)), xs)
qs(n, nil) → nil
qs(n, cons(x, xs)) → append(qs(half(n), filterlow(get(n, cons(x, xs)), cons(x, xs))), cons(get(n, cons(x, xs)), qs(half(n), filterhigh(get(n, cons(x, xs)), cons(x, xs)))))
filterlow(n, nil) → nil
filterlow(n, cons(x, xs)) → if1(ge(n, x), n, x, xs)
if1(true, n, x, xs) → filterlow(n, xs)
if1(false, n, x, xs) → cons(x, filterlow(n, xs))
filterhigh(n, nil) → nil
filterhigh(n, cons(x, xs)) → if2(ge(x, n), n, x, xs)
if2(true, n, x, xs) → filterhigh(n, xs)
if2(false, n, x, xs) → cons(x, filterhigh(n, xs))
ge(x, 0) → true
ge(0, s(x)) → false
ge(s(x), s(y)) → ge(x, y)
append(nil, ys) → ys
append(cons(x, xs), ys) → cons(x, append(xs, ys))
length(nil) → 0
length(cons(x, xs)) → s(length(xs))
half(0) → 0
half(s(0)) → 0
half(s(s(x))) → s(half(x))
get(n, nil) → 0
get(n, cons(x, nil)) → x
get(0, cons(x, cons(y, xs))) → x
get(s(n), cons(x, cons(y, xs))) → get(n, cons(y, xs))

The set Q consists of the following terms:

qsort(x0)
qs(x0, nil)
qs(x0, cons(x1, x2))
filterlow(x0, nil)
filterlow(x0, cons(x1, x2))
if1(true, x0, x1, x2)
if1(false, x0, x1, x2)
filterhigh(x0, nil)
filterhigh(x0, cons(x1, x2))
if2(true, x0, x1, x2)
if2(false, x0, x1, x2)
ge(x0, 0)
ge(0, s(x0))
ge(s(x0), s(x1))
append(nil, ys)
append(cons(x0, x1), ys)
length(nil)
length(cons(x0, x1))
half(0)
half(s(0))
half(s(s(x0)))
get(x0, nil)
get(x0, cons(x1, nil))
get(0, cons(x0, cons(x1, x2)))
get(s(x0), cons(x1, cons(x2, x3)))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

Q DP problem:
The TRS P consists of the following rules:

QS(n, cons(x, xs)) → QS(half(n), filterhigh(get(n, cons(x, xs)), cons(x, xs)))
QS(n, cons(x, xs)) → QS(half(n), filterlow(get(n, cons(x, xs)), cons(x, xs)))

The TRS R consists of the following rules:

half(0) → 0
half(s(0)) → 0
half(s(s(x))) → s(half(x))
get(n, cons(x, nil)) → x
get(0, cons(x, cons(y, xs))) → x
get(s(n), cons(x, cons(y, xs))) → get(n, cons(y, xs))
if2(true, n, x, xs) → filterhigh(n, xs)
filterhigh(n, cons(x, xs)) → if2(ge(x, n), n, x, xs)
ge(x, 0) → true
ge(0, s(x)) → false
ge(s(x), s(y)) → ge(x, y)
if2(false, n, x, xs) → cons(x, filterhigh(n, xs))
filterhigh(n, nil) → nil
if1(true, n, x, xs) → filterlow(n, xs)
filterlow(n, cons(x, xs)) → if1(ge(n, x), n, x, xs)
if1(false, n, x, xs) → cons(x, filterlow(n, xs))
filterlow(n, nil) → nil

The set Q consists of the following terms:

qsort(x0)
qs(x0, nil)
qs(x0, cons(x1, x2))
filterlow(x0, nil)
filterlow(x0, cons(x1, x2))
if1(true, x0, x1, x2)
if1(false, x0, x1, x2)
filterhigh(x0, nil)
filterhigh(x0, cons(x1, x2))
if2(true, x0, x1, x2)
if2(false, x0, x1, x2)
ge(x0, 0)
ge(0, s(x0))
ge(s(x0), s(x1))
append(nil, ys)
append(cons(x0, x1), ys)
length(nil)
length(cons(x0, x1))
half(0)
half(s(0))
half(s(s(x0)))
get(x0, nil)
get(x0, cons(x1, nil))
get(0, cons(x0, cons(x1, x2)))
get(s(x0), cons(x1, cons(x2, x3)))

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN].

qsort(x0)
qs(x0, nil)
qs(x0, cons(x1, x2))
append(nil, ys)
append(cons(x0, x1), ys)
length(nil)
length(cons(x0, x1))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

QS(n, cons(x, xs)) → QS(half(n), filterhigh(get(n, cons(x, xs)), cons(x, xs)))
QS(n, cons(x, xs)) → QS(half(n), filterlow(get(n, cons(x, xs)), cons(x, xs)))

The TRS R consists of the following rules:

half(0) → 0
half(s(0)) → 0
half(s(s(x))) → s(half(x))
get(n, cons(x, nil)) → x
get(0, cons(x, cons(y, xs))) → x
get(s(n), cons(x, cons(y, xs))) → get(n, cons(y, xs))
if2(true, n, x, xs) → filterhigh(n, xs)
filterhigh(n, cons(x, xs)) → if2(ge(x, n), n, x, xs)
ge(x, 0) → true
ge(0, s(x)) → false
ge(s(x), s(y)) → ge(x, y)
if2(false, n, x, xs) → cons(x, filterhigh(n, xs))
filterhigh(n, nil) → nil
if1(true, n, x, xs) → filterlow(n, xs)
filterlow(n, cons(x, xs)) → if1(ge(n, x), n, x, xs)
if1(false, n, x, xs) → cons(x, filterlow(n, xs))
filterlow(n, nil) → nil

The set Q consists of the following terms:

filterlow(x0, nil)
filterlow(x0, cons(x1, x2))
if1(true, x0, x1, x2)
if1(false, x0, x1, x2)
filterhigh(x0, nil)
filterhigh(x0, cons(x1, x2))
if2(true, x0, x1, x2)
if2(false, x0, x1, x2)
ge(x0, 0)
ge(0, s(x0))
ge(s(x0), s(x1))
half(0)
half(s(0))
half(s(s(x0)))
get(x0, nil)
get(x0, cons(x1, nil))
get(0, cons(x0, cons(x1, x2)))
get(s(x0), cons(x1, cons(x2, x3)))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule QS(n, cons(x, xs)) → QS(half(n), filterhigh(get(n, cons(x, xs)), cons(x, xs))) at position [1] we obtained the following new rules [LPAR04]:

QS(n, cons(x, xs)) → QS(half(n), if2(ge(x, get(n, cons(x, xs))), get(n, cons(x, xs)), x, xs))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Rewriting

                          ↳ QDP

                            ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

QS(n, cons(x, xs)) → QS(half(n), filterlow(get(n, cons(x, xs)), cons(x, xs)))
QS(n, cons(x, xs)) → QS(half(n), if2(ge(x, get(n, cons(x, xs))), get(n, cons(x, xs)), x, xs))

The TRS R consists of the following rules:

half(0) → 0
half(s(0)) → 0
half(s(s(x))) → s(half(x))
get(n, cons(x, nil)) → x
get(0, cons(x, cons(y, xs))) → x
get(s(n), cons(x, cons(y, xs))) → get(n, cons(y, xs))
if2(true, n, x, xs) → filterhigh(n, xs)
filterhigh(n, cons(x, xs)) → if2(ge(x, n), n, x, xs)
ge(x, 0) → true
ge(0, s(x)) → false
ge(s(x), s(y)) → ge(x, y)
if2(false, n, x, xs) → cons(x, filterhigh(n, xs))
filterhigh(n, nil) → nil
if1(true, n, x, xs) → filterlow(n, xs)
filterlow(n, cons(x, xs)) → if1(ge(n, x), n, x, xs)
if1(false, n, x, xs) → cons(x, filterlow(n, xs))
filterlow(n, nil) → nil

The set Q consists of the following terms:

filterlow(x0, nil)
filterlow(x0, cons(x1, x2))
if1(true, x0, x1, x2)
if1(false, x0, x1, x2)
filterhigh(x0, nil)
filterhigh(x0, cons(x1, x2))
if2(true, x0, x1, x2)
if2(false, x0, x1, x2)
ge(x0, 0)
ge(0, s(x0))
ge(s(x0), s(x1))
half(0)
half(s(0))
half(s(s(x0)))
get(x0, nil)
get(x0, cons(x1, nil))
get(0, cons(x0, cons(x1, x2)))
get(s(x0), cons(x1, cons(x2, x3)))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule QS(n, cons(x, xs)) → QS(half(n), filterlow(get(n, cons(x, xs)), cons(x, xs))) at position [1] we obtained the following new rules [LPAR04]:

QS(n, cons(x, xs)) → QS(half(n), if1(ge(get(n, cons(x, xs)), x), get(n, cons(x, xs)), x, xs))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Rewriting

                          ↳ QDP

                            ↳ Rewriting

                              ↳ QDP

                                ↳ Narrowing

Q DP problem:
The TRS P consists of the following rules:

QS(n, cons(x, xs)) → QS(half(n), if2(ge(x, get(n, cons(x, xs))), get(n, cons(x, xs)), x, xs))
QS(n, cons(x, xs)) → QS(half(n), if1(ge(get(n, cons(x, xs)), x), get(n, cons(x, xs)), x, xs))

The TRS R consists of the following rules:

half(0) → 0
half(s(0)) → 0
half(s(s(x))) → s(half(x))
get(n, cons(x, nil)) → x
get(0, cons(x, cons(y, xs))) → x
get(s(n), cons(x, cons(y, xs))) → get(n, cons(y, xs))
if2(true, n, x, xs) → filterhigh(n, xs)
filterhigh(n, cons(x, xs)) → if2(ge(x, n), n, x, xs)
ge(x, 0) → true
ge(0, s(x)) → false
ge(s(x), s(y)) → ge(x, y)
if2(false, n, x, xs) → cons(x, filterhigh(n, xs))
filterhigh(n, nil) → nil
if1(true, n, x, xs) → filterlow(n, xs)
filterlow(n, cons(x, xs)) → if1(ge(n, x), n, x, xs)
if1(false, n, x, xs) → cons(x, filterlow(n, xs))
filterlow(n, nil) → nil

The set Q consists of the following terms:

filterlow(x0, nil)
filterlow(x0, cons(x1, x2))
if1(true, x0, x1, x2)
if1(false, x0, x1, x2)
filterhigh(x0, nil)
filterhigh(x0, cons(x1, x2))
if2(true, x0, x1, x2)
if2(false, x0, x1, x2)
ge(x0, 0)
ge(0, s(x0))
ge(s(x0), s(x1))
half(0)
half(s(0))
half(s(s(x0)))
get(x0, nil)
get(x0, cons(x1, nil))
get(0, cons(x0, cons(x1, x2)))
get(s(x0), cons(x1, cons(x2, x3)))

We have to consider all minimal (P,Q,R)-chains.
By narrowing [LPAR04] the rule QS(n, cons(x, xs)) → QS(half(n), if2(ge(x, get(n, cons(x, xs))), get(n, cons(x, xs)), x, xs)) at position [1] we obtained the following new rules [LPAR04]:

QS(0, cons(x0, cons(x1, x2))) → QS(half(0), if2(ge(x0, x0), get(0, cons(x0, cons(x1, x2))), x0, cons(x1, x2)))
QS(x0, cons(x1, nil)) → QS(half(x0), if2(ge(x1, x1), get(x0, cons(x1, nil)), x1, nil))
QS(s(x0), cons(x1, cons(x2, x3))) → QS(half(s(x0)), if2(ge(x1, get(s(x0), cons(x1, cons(x2, x3)))), get(x0, cons(x2, x3)), x1, cons(x2, x3)))
QS(0, cons(x0, cons(x1, x2))) → QS(half(0), if2(ge(x0, get(0, cons(x0, cons(x1, x2)))), x0, x0, cons(x1, x2)))
QS(x0, cons(x1, nil)) → QS(half(x0), if2(ge(x1, get(x0, cons(x1, nil))), x1, x1, nil))
QS(s(x0), cons(x1, cons(x2, x3))) → QS(half(s(x0)), if2(ge(x1, get(x0, cons(x2, x3))), get(s(x0), cons(x1, cons(x2, x3))), x1, cons(x2, x3)))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Rewriting

                          ↳ QDP

                            ↳ Rewriting

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

QS(n, cons(x, xs)) → QS(half(n), if1(ge(get(n, cons(x, xs)), x), get(n, cons(x, xs)), x, xs))
QS(0, cons(x0, cons(x1, x2))) → QS(half(0), if2(ge(x0, x0), get(0, cons(x0, cons(x1, x2))), x0, cons(x1, x2)))
QS(x0, cons(x1, nil)) → QS(half(x0), if2(ge(x1, x1), get(x0, cons(x1, nil)), x1, nil))
QS(s(x0), cons(x1, cons(x2, x3))) → QS(half(s(x0)), if2(ge(x1, get(s(x0), cons(x1, cons(x2, x3)))), get(x0, cons(x2, x3)), x1, cons(x2, x3)))
QS(0, cons(x0, cons(x1, x2))) → QS(half(0), if2(ge(x0, get(0, cons(x0, cons(x1, x2)))), x0, x0, cons(x1, x2)))
QS(x0, cons(x1, nil)) → QS(half(x0), if2(ge(x1, get(x0, cons(x1, nil))), x1, x1, nil))
QS(s(x0), cons(x1, cons(x2, x3))) → QS(half(s(x0)), if2(ge(x1, get(x0, cons(x2, x3))), get(s(x0), cons(x1, cons(x2, x3))), x1, cons(x2, x3)))

The TRS R consists of the following rules:

half(0) → 0
half(s(0)) → 0
half(s(s(x))) → s(half(x))
get(n, cons(x, nil)) → x
get(0, cons(x, cons(y, xs))) → x
get(s(n), cons(x, cons(y, xs))) → get(n, cons(y, xs))
if2(true, n, x, xs) → filterhigh(n, xs)
filterhigh(n, cons(x, xs)) → if2(ge(x, n), n, x, xs)
ge(x, 0) → true
ge(0, s(x)) → false
ge(s(x), s(y)) → ge(x, y)
if2(false, n, x, xs) → cons(x, filterhigh(n, xs))
filterhigh(n, nil) → nil
if1(true, n, x, xs) → filterlow(n, xs)
filterlow(n, cons(x, xs)) → if1(ge(n, x), n, x, xs)
if1(false, n, x, xs) → cons(x, filterlow(n, xs))
filterlow(n, nil) → nil

The set Q consists of the following terms:

filterlow(x0, nil)
filterlow(x0, cons(x1, x2))
if1(true, x0, x1, x2)
if1(false, x0, x1, x2)
filterhigh(x0, nil)
filterhigh(x0, cons(x1, x2))
if2(true, x0, x1, x2)
if2(false, x0, x1, x2)
ge(x0, 0)
ge(0, s(x0))
ge(s(x0), s(x1))
half(0)
half(s(0))
half(s(s(x0)))
get(x0, nil)
get(x0, cons(x1, nil))
get(0, cons(x0, cons(x1, x2)))
get(s(x0), cons(x1, cons(x2, x3)))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule QS(0, cons(x0, cons(x1, x2))) → QS(half(0), if2(ge(x0, x0), get(0, cons(x0, cons(x1, x2))), x0, cons(x1, x2))) at position [0] we obtained the following new rules [LPAR04]:

QS(0, cons(x0, cons(x1, x2))) → QS(0, if2(ge(x0, x0), get(0, cons(x0, cons(x1, x2))), x0, cons(x1, x2)))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Rewriting

                          ↳ QDP

                            ↳ Rewriting

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

QS(n, cons(x, xs)) → QS(half(n), if1(ge(get(n, cons(x, xs)), x), get(n, cons(x, xs)), x, xs))
QS(x0, cons(x1, nil)) → QS(half(x0), if2(ge(x1, x1), get(x0, cons(x1, nil)), x1, nil))
QS(s(x0), cons(x1, cons(x2, x3))) → QS(half(s(x0)), if2(ge(x1, get(s(x0), cons(x1, cons(x2, x3)))), get(x0, cons(x2, x3)), x1, cons(x2, x3)))
QS(0, cons(x0, cons(x1, x2))) → QS(half(0), if2(ge(x0, get(0, cons(x0, cons(x1, x2)))), x0, x0, cons(x1, x2)))
QS(x0, cons(x1, nil)) → QS(half(x0), if2(ge(x1, get(x0, cons(x1, nil))), x1, x1, nil))
QS(s(x0), cons(x1, cons(x2, x3))) → QS(half(s(x0)), if2(ge(x1, get(x0, cons(x2, x3))), get(s(x0), cons(x1, cons(x2, x3))), x1, cons(x2, x3)))
QS(0, cons(x0, cons(x1, x2))) → QS(0, if2(ge(x0, x0), get(0, cons(x0, cons(x1, x2))), x0, cons(x1, x2)))

The TRS R consists of the following rules:

half(0) → 0
half(s(0)) → 0
half(s(s(x))) → s(half(x))
get(n, cons(x, nil)) → x
get(0, cons(x, cons(y, xs))) → x
get(s(n), cons(x, cons(y, xs))) → get(n, cons(y, xs))
if2(true, n, x, xs) → filterhigh(n, xs)
filterhigh(n, cons(x, xs)) → if2(ge(x, n), n, x, xs)
ge(x, 0) → true
ge(0, s(x)) → false
ge(s(x), s(y)) → ge(x, y)
if2(false, n, x, xs) → cons(x, filterhigh(n, xs))
filterhigh(n, nil) → nil
if1(true, n, x, xs) → filterlow(n, xs)
filterlow(n, cons(x, xs)) → if1(ge(n, x), n, x, xs)
if1(false, n, x, xs) → cons(x, filterlow(n, xs))
filterlow(n, nil) → nil

The set Q consists of the following terms:

filterlow(x0, nil)
filterlow(x0, cons(x1, x2))
if1(true, x0, x1, x2)
if1(false, x0, x1, x2)
filterhigh(x0, nil)
filterhigh(x0, cons(x1, x2))
if2(true, x0, x1, x2)
if2(false, x0, x1, x2)
ge(x0, 0)
ge(0, s(x0))
ge(s(x0), s(x1))
half(0)
half(s(0))
half(s(s(x0)))
get(x0, nil)
get(x0, cons(x1, nil))
get(0, cons(x0, cons(x1, x2)))
get(s(x0), cons(x1, cons(x2, x3)))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule QS(x0, cons(x1, nil)) → QS(half(x0), if2(ge(x1, x1), get(x0, cons(x1, nil)), x1, nil)) at position [1,1] we obtained the following new rules [LPAR04]:

QS(x0, cons(x1, nil)) → QS(half(x0), if2(ge(x1, x1), x1, x1, nil))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Rewriting

                          ↳ QDP

                            ↳ Rewriting

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

QS(n, cons(x, xs)) → QS(half(n), if1(ge(get(n, cons(x, xs)), x), get(n, cons(x, xs)), x, xs))
QS(s(x0), cons(x1, cons(x2, x3))) → QS(half(s(x0)), if2(ge(x1, get(s(x0), cons(x1, cons(x2, x3)))), get(x0, cons(x2, x3)), x1, cons(x2, x3)))
QS(0, cons(x0, cons(x1, x2))) → QS(half(0), if2(ge(x0, get(0, cons(x0, cons(x1, x2)))), x0, x0, cons(x1, x2)))
QS(x0, cons(x1, nil)) → QS(half(x0), if2(ge(x1, get(x0, cons(x1, nil))), x1, x1, nil))
QS(s(x0), cons(x1, cons(x2, x3))) → QS(half(s(x0)), if2(ge(x1, get(x0, cons(x2, x3))), get(s(x0), cons(x1, cons(x2, x3))), x1, cons(x2, x3)))
QS(0, cons(x0, cons(x1, x2))) → QS(0, if2(ge(x0, x0), get(0, cons(x0, cons(x1, x2))), x0, cons(x1, x2)))
QS(x0, cons(x1, nil)) → QS(half(x0), if2(ge(x1, x1), x1, x1, nil))

The TRS R consists of the following rules:

half(0) → 0
half(s(0)) → 0
half(s(s(x))) → s(half(x))
get(n, cons(x, nil)) → x
get(0, cons(x, cons(y, xs))) → x
get(s(n), cons(x, cons(y, xs))) → get(n, cons(y, xs))
if2(true, n, x, xs) → filterhigh(n, xs)
filterhigh(n, cons(x, xs)) → if2(ge(x, n), n, x, xs)
ge(x, 0) → true
ge(0, s(x)) → false
ge(s(x), s(y)) → ge(x, y)
if2(false, n, x, xs) → cons(x, filterhigh(n, xs))
filterhigh(n, nil) → nil
if1(true, n, x, xs) → filterlow(n, xs)
filterlow(n, cons(x, xs)) → if1(ge(n, x), n, x, xs)
if1(false, n, x, xs) → cons(x, filterlow(n, xs))
filterlow(n, nil) → nil

The set Q consists of the following terms:

filterlow(x0, nil)
filterlow(x0, cons(x1, x2))
if1(true, x0, x1, x2)
if1(false, x0, x1, x2)
filterhigh(x0, nil)
filterhigh(x0, cons(x1, x2))
if2(true, x0, x1, x2)
if2(false, x0, x1, x2)
ge(x0, 0)
ge(0, s(x0))
ge(s(x0), s(x1))
half(0)
half(s(0))
half(s(s(x0)))
get(x0, nil)
get(x0, cons(x1, nil))
get(0, cons(x0, cons(x1, x2)))
get(s(x0), cons(x1, cons(x2, x3)))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule QS(s(x0), cons(x1, cons(x2, x3))) → QS(half(s(x0)), if2(ge(x1, get(s(x0), cons(x1, cons(x2, x3)))), get(x0, cons(x2, x3)), x1, cons(x2, x3))) at position [1,0,1] we obtained the following new rules [LPAR04]:

QS(s(x0), cons(x1, cons(x2, x3))) → QS(half(s(x0)), if2(ge(x1, get(x0, cons(x2, x3))), get(x0, cons(x2, x3)), x1, cons(x2, x3)))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Rewriting

                          ↳ QDP

                            ↳ Rewriting

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

QS(n, cons(x, xs)) → QS(half(n), if1(ge(get(n, cons(x, xs)), x), get(n, cons(x, xs)), x, xs))
QS(0, cons(x0, cons(x1, x2))) → QS(half(0), if2(ge(x0, get(0, cons(x0, cons(x1, x2)))), x0, x0, cons(x1, x2)))
QS(x0, cons(x1, nil)) → QS(half(x0), if2(ge(x1, get(x0, cons(x1, nil))), x1, x1, nil))
QS(s(x0), cons(x1, cons(x2, x3))) → QS(half(s(x0)), if2(ge(x1, get(x0, cons(x2, x3))), get(s(x0), cons(x1, cons(x2, x3))), x1, cons(x2, x3)))
QS(0, cons(x0, cons(x1, x2))) → QS(0, if2(ge(x0, x0), get(0, cons(x0, cons(x1, x2))), x0, cons(x1, x2)))
QS(x0, cons(x1, nil)) → QS(half(x0), if2(ge(x1, x1), x1, x1, nil))
QS(s(x0), cons(x1, cons(x2, x3))) → QS(half(s(x0)), if2(ge(x1, get(x0, cons(x2, x3))), get(x0, cons(x2, x3)), x1, cons(x2, x3)))

The TRS R consists of the following rules:

half(0) → 0
half(s(0)) → 0
half(s(s(x))) → s(half(x))
get(n, cons(x, nil)) → x
get(0, cons(x, cons(y, xs))) → x
get(s(n), cons(x, cons(y, xs))) → get(n, cons(y, xs))
if2(true, n, x, xs) → filterhigh(n, xs)
filterhigh(n, cons(x, xs)) → if2(ge(x, n), n, x, xs)
ge(x, 0) → true
ge(0, s(x)) → false
ge(s(x), s(y)) → ge(x, y)
if2(false, n, x, xs) → cons(x, filterhigh(n, xs))
filterhigh(n, nil) → nil
if1(true, n, x, xs) → filterlow(n, xs)
filterlow(n, cons(x, xs)) → if1(ge(n, x), n, x, xs)
if1(false, n, x, xs) → cons(x, filterlow(n, xs))
filterlow(n, nil) → nil

The set Q consists of the following terms:

filterlow(x0, nil)
filterlow(x0, cons(x1, x2))
if1(true, x0, x1, x2)
if1(false, x0, x1, x2)
filterhigh(x0, nil)
filterhigh(x0, cons(x1, x2))
if2(true, x0, x1, x2)
if2(false, x0, x1, x2)
ge(x0, 0)
ge(0, s(x0))
ge(s(x0), s(x1))
half(0)
half(s(0))
half(s(s(x0)))
get(x0, nil)
get(x0, cons(x1, nil))
get(0, cons(x0, cons(x1, x2)))
get(s(x0), cons(x1, cons(x2, x3)))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule QS(0, cons(x0, cons(x1, x2))) → QS(half(0), if2(ge(x0, get(0, cons(x0, cons(x1, x2)))), x0, x0, cons(x1, x2))) at position [0] we obtained the following new rules [LPAR04]:

QS(0, cons(x0, cons(x1, x2))) → QS(0, if2(ge(x0, get(0, cons(x0, cons(x1, x2)))), x0, x0, cons(x1, x2)))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Rewriting

                          ↳ QDP

                            ↳ Rewriting

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

QS(n, cons(x, xs)) → QS(half(n), if1(ge(get(n, cons(x, xs)), x), get(n, cons(x, xs)), x, xs))
QS(x0, cons(x1, nil)) → QS(half(x0), if2(ge(x1, get(x0, cons(x1, nil))), x1, x1, nil))
QS(s(x0), cons(x1, cons(x2, x3))) → QS(half(s(x0)), if2(ge(x1, get(x0, cons(x2, x3))), get(s(x0), cons(x1, cons(x2, x3))), x1, cons(x2, x3)))
QS(0, cons(x0, cons(x1, x2))) → QS(0, if2(ge(x0, x0), get(0, cons(x0, cons(x1, x2))), x0, cons(x1, x2)))
QS(x0, cons(x1, nil)) → QS(half(x0), if2(ge(x1, x1), x1, x1, nil))
QS(s(x0), cons(x1, cons(x2, x3))) → QS(half(s(x0)), if2(ge(x1, get(x0, cons(x2, x3))), get(x0, cons(x2, x3)), x1, cons(x2, x3)))
QS(0, cons(x0, cons(x1, x2))) → QS(0, if2(ge(x0, get(0, cons(x0, cons(x1, x2)))), x0, x0, cons(x1, x2)))

The TRS R consists of the following rules:

half(0) → 0
half(s(0)) → 0
half(s(s(x))) → s(half(x))
get(n, cons(x, nil)) → x
get(0, cons(x, cons(y, xs))) → x
get(s(n), cons(x, cons(y, xs))) → get(n, cons(y, xs))
if2(true, n, x, xs) → filterhigh(n, xs)
filterhigh(n, cons(x, xs)) → if2(ge(x, n), n, x, xs)
ge(x, 0) → true
ge(0, s(x)) → false
ge(s(x), s(y)) → ge(x, y)
if2(false, n, x, xs) → cons(x, filterhigh(n, xs))
filterhigh(n, nil) → nil
if1(true, n, x, xs) → filterlow(n, xs)
filterlow(n, cons(x, xs)) → if1(ge(n, x), n, x, xs)
if1(false, n, x, xs) → cons(x, filterlow(n, xs))
filterlow(n, nil) → nil

The set Q consists of the following terms:

filterlow(x0, nil)
filterlow(x0, cons(x1, x2))
if1(true, x0, x1, x2)
if1(false, x0, x1, x2)
filterhigh(x0, nil)
filterhigh(x0, cons(x1, x2))
if2(true, x0, x1, x2)
if2(false, x0, x1, x2)
ge(x0, 0)
ge(0, s(x0))
ge(s(x0), s(x1))
half(0)
half(s(0))
half(s(s(x0)))
get(x0, nil)
get(x0, cons(x1, nil))
get(0, cons(x0, cons(x1, x2)))
get(s(x0), cons(x1, cons(x2, x3)))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule QS(x0, cons(x1, nil)) → QS(half(x0), if2(ge(x1, get(x0, cons(x1, nil))), x1, x1, nil)) at position [1,0,1] we obtained the following new rules [LPAR04]:

QS(x0, cons(x1, nil)) → QS(half(x0), if2(ge(x1, x1), x1, x1, nil))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Rewriting

                          ↳ QDP

                            ↳ Rewriting

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Rewriting

                                                      ↳ QDP

                                                        ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

QS(n, cons(x, xs)) → QS(half(n), if1(ge(get(n, cons(x, xs)), x), get(n, cons(x, xs)), x, xs))
QS(s(x0), cons(x1, cons(x2, x3))) → QS(half(s(x0)), if2(ge(x1, get(x0, cons(x2, x3))), get(s(x0), cons(x1, cons(x2, x3))), x1, cons(x2, x3)))
QS(0, cons(x0, cons(x1, x2))) → QS(0, if2(ge(x0, x0), get(0, cons(x0, cons(x1, x2))), x0, cons(x1, x2)))
QS(x0, cons(x1, nil)) → QS(half(x0), if2(ge(x1, x1), x1, x1, nil))
QS(s(x0), cons(x1, cons(x2, x3))) → QS(half(s(x0)), if2(ge(x1, get(x0, cons(x2, x3))), get(x0, cons(x2, x3)), x1, cons(x2, x3)))
QS(0, cons(x0, cons(x1, x2))) → QS(0, if2(ge(x0, get(0, cons(x0, cons(x1, x2)))), x0, x0, cons(x1, x2)))

The TRS R consists of the following rules:

half(0) → 0
half(s(0)) → 0
half(s(s(x))) → s(half(x))
get(n, cons(x, nil)) → x
get(0, cons(x, cons(y, xs))) → x
get(s(n), cons(x, cons(y, xs))) → get(n, cons(y, xs))
if2(true, n, x, xs) → filterhigh(n, xs)
filterhigh(n, cons(x, xs)) → if2(ge(x, n), n, x, xs)
ge(x, 0) → true
ge(0, s(x)) → false
ge(s(x), s(y)) → ge(x, y)
if2(false, n, x, xs) → cons(x, filterhigh(n, xs))
filterhigh(n, nil) → nil
if1(true, n, x, xs) → filterlow(n, xs)
filterlow(n, cons(x, xs)) → if1(ge(n, x), n, x, xs)
if1(false, n, x, xs) → cons(x, filterlow(n, xs))
filterlow(n, nil) → nil

The set Q consists of the following terms:

filterlow(x0, nil)
filterlow(x0, cons(x1, x2))
if1(true, x0, x1, x2)
if1(false, x0, x1, x2)
filterhigh(x0, nil)
filterhigh(x0, cons(x1, x2))
if2(true, x0, x1, x2)
if2(false, x0, x1, x2)
ge(x0, 0)
ge(0, s(x0))
ge(s(x0), s(x1))
half(0)
half(s(0))
half(s(s(x0)))
get(x0, nil)
get(x0, cons(x1, nil))
get(0, cons(x0, cons(x1, x2)))
get(s(x0), cons(x1, cons(x2, x3)))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule QS(s(x0), cons(x1, cons(x2, x3))) → QS(half(s(x0)), if2(ge(x1, get(x0, cons(x2, x3))), get(s(x0), cons(x1, cons(x2, x3))), x1, cons(x2, x3))) at position [1,1] we obtained the following new rules [LPAR04]:

QS(s(x0), cons(x1, cons(x2, x3))) → QS(half(s(x0)), if2(ge(x1, get(x0, cons(x2, x3))), get(x0, cons(x2, x3)), x1, cons(x2, x3)))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Rewriting

                          ↳ QDP

                            ↳ Rewriting

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Rewriting

                                                      ↳ QDP

                                                        ↳ Rewriting

                                                          ↳ QDP

                                                            ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

QS(n, cons(x, xs)) → QS(half(n), if1(ge(get(n, cons(x, xs)), x), get(n, cons(x, xs)), x, xs))
QS(0, cons(x0, cons(x1, x2))) → QS(0, if2(ge(x0, x0), get(0, cons(x0, cons(x1, x2))), x0, cons(x1, x2)))
QS(x0, cons(x1, nil)) → QS(half(x0), if2(ge(x1, x1), x1, x1, nil))
QS(s(x0), cons(x1, cons(x2, x3))) → QS(half(s(x0)), if2(ge(x1, get(x0, cons(x2, x3))), get(x0, cons(x2, x3)), x1, cons(x2, x3)))
QS(0, cons(x0, cons(x1, x2))) → QS(0, if2(ge(x0, get(0, cons(x0, cons(x1, x2)))), x0, x0, cons(x1, x2)))

The TRS R consists of the following rules:

half(0) → 0
half(s(0)) → 0
half(s(s(x))) → s(half(x))
get(n, cons(x, nil)) → x
get(0, cons(x, cons(y, xs))) → x
get(s(n), cons(x, cons(y, xs))) → get(n, cons(y, xs))
if2(true, n, x, xs) → filterhigh(n, xs)
filterhigh(n, cons(x, xs)) → if2(ge(x, n), n, x, xs)
ge(x, 0) → true
ge(0, s(x)) → false
ge(s(x), s(y)) → ge(x, y)
if2(false, n, x, xs) → cons(x, filterhigh(n, xs))
filterhigh(n, nil) → nil
if1(true, n, x, xs) → filterlow(n, xs)
filterlow(n, cons(x, xs)) → if1(ge(n, x), n, x, xs)
if1(false, n, x, xs) → cons(x, filterlow(n, xs))
filterlow(n, nil) → nil

The set Q consists of the following terms:

filterlow(x0, nil)
filterlow(x0, cons(x1, x2))
if1(true, x0, x1, x2)
if1(false, x0, x1, x2)
filterhigh(x0, nil)
filterhigh(x0, cons(x1, x2))
if2(true, x0, x1, x2)
if2(false, x0, x1, x2)
ge(x0, 0)
ge(0, s(x0))
ge(s(x0), s(x1))
half(0)
half(s(0))
half(s(s(x0)))
get(x0, nil)
get(x0, cons(x1, nil))
get(0, cons(x0, cons(x1, x2)))
get(s(x0), cons(x1, cons(x2, x3)))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule QS(0, cons(x0, cons(x1, x2))) → QS(0, if2(ge(x0, x0), get(0, cons(x0, cons(x1, x2))), x0, cons(x1, x2))) at position [1,1] we obtained the following new rules [LPAR04]:

QS(0, cons(x0, cons(x1, x2))) → QS(0, if2(ge(x0, x0), x0, x0, cons(x1, x2)))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Rewriting

                          ↳ QDP

                            ↳ Rewriting

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Rewriting

                                                      ↳ QDP

                                                        ↳ Rewriting

                                                          ↳ QDP

                                                            ↳ Rewriting

                                                              ↳ QDP

                                                                ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

QS(n, cons(x, xs)) → QS(half(n), if1(ge(get(n, cons(x, xs)), x), get(n, cons(x, xs)), x, xs))
QS(x0, cons(x1, nil)) → QS(half(x0), if2(ge(x1, x1), x1, x1, nil))
QS(s(x0), cons(x1, cons(x2, x3))) → QS(half(s(x0)), if2(ge(x1, get(x0, cons(x2, x3))), get(x0, cons(x2, x3)), x1, cons(x2, x3)))
QS(0, cons(x0, cons(x1, x2))) → QS(0, if2(ge(x0, get(0, cons(x0, cons(x1, x2)))), x0, x0, cons(x1, x2)))
QS(0, cons(x0, cons(x1, x2))) → QS(0, if2(ge(x0, x0), x0, x0, cons(x1, x2)))

The TRS R consists of the following rules:

half(0) → 0
half(s(0)) → 0
half(s(s(x))) → s(half(x))
get(n, cons(x, nil)) → x
get(0, cons(x, cons(y, xs))) → x
get(s(n), cons(x, cons(y, xs))) → get(n, cons(y, xs))
if2(true, n, x, xs) → filterhigh(n, xs)
filterhigh(n, cons(x, xs)) → if2(ge(x, n), n, x, xs)
ge(x, 0) → true
ge(0, s(x)) → false
ge(s(x), s(y)) → ge(x, y)
if2(false, n, x, xs) → cons(x, filterhigh(n, xs))
filterhigh(n, nil) → nil
if1(true, n, x, xs) → filterlow(n, xs)
filterlow(n, cons(x, xs)) → if1(ge(n, x), n, x, xs)
if1(false, n, x, xs) → cons(x, filterlow(n, xs))
filterlow(n, nil) → nil

The set Q consists of the following terms:

filterlow(x0, nil)
filterlow(x0, cons(x1, x2))
if1(true, x0, x1, x2)
if1(false, x0, x1, x2)
filterhigh(x0, nil)
filterhigh(x0, cons(x1, x2))
if2(true, x0, x1, x2)
if2(false, x0, x1, x2)
ge(x0, 0)
ge(0, s(x0))
ge(s(x0), s(x1))
half(0)
half(s(0))
half(s(s(x0)))
get(x0, nil)
get(x0, cons(x1, nil))
get(0, cons(x0, cons(x1, x2)))
get(s(x0), cons(x1, cons(x2, x3)))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule QS(0, cons(x0, cons(x1, x2))) → QS(0, if2(ge(x0, get(0, cons(x0, cons(x1, x2)))), x0, x0, cons(x1, x2))) at position [1,0,1] we obtained the following new rules [LPAR04]:

QS(0, cons(x0, cons(x1, x2))) → QS(0, if2(ge(x0, x0), x0, x0, cons(x1, x2)))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Rewriting

                          ↳ QDP

                            ↳ Rewriting

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Rewriting

                                                      ↳ QDP

                                                        ↳ Rewriting

                                                          ↳ QDP

                                                            ↳ Rewriting

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Narrowing

Q DP problem:
The TRS P consists of the following rules:

QS(n, cons(x, xs)) → QS(half(n), if1(ge(get(n, cons(x, xs)), x), get(n, cons(x, xs)), x, xs))
QS(x0, cons(x1, nil)) → QS(half(x0), if2(ge(x1, x1), x1, x1, nil))
QS(s(x0), cons(x1, cons(x2, x3))) → QS(half(s(x0)), if2(ge(x1, get(x0, cons(x2, x3))), get(x0, cons(x2, x3)), x1, cons(x2, x3)))
QS(0, cons(x0, cons(x1, x2))) → QS(0, if2(ge(x0, x0), x0, x0, cons(x1, x2)))

The TRS R consists of the following rules:

half(0) → 0
half(s(0)) → 0
half(s(s(x))) → s(half(x))
get(n, cons(x, nil)) → x
get(0, cons(x, cons(y, xs))) → x
get(s(n), cons(x, cons(y, xs))) → get(n, cons(y, xs))
if2(true, n, x, xs) → filterhigh(n, xs)
filterhigh(n, cons(x, xs)) → if2(ge(x, n), n, x, xs)
ge(x, 0) → true
ge(0, s(x)) → false
ge(s(x), s(y)) → ge(x, y)
if2(false, n, x, xs) → cons(x, filterhigh(n, xs))
filterhigh(n, nil) → nil
if1(true, n, x, xs) → filterlow(n, xs)
filterlow(n, cons(x, xs)) → if1(ge(n, x), n, x, xs)
if1(false, n, x, xs) → cons(x, filterlow(n, xs))
filterlow(n, nil) → nil

The set Q consists of the following terms:

filterlow(x0, nil)
filterlow(x0, cons(x1, x2))
if1(true, x0, x1, x2)
if1(false, x0, x1, x2)
filterhigh(x0, nil)
filterhigh(x0, cons(x1, x2))
if2(true, x0, x1, x2)
if2(false, x0, x1, x2)
ge(x0, 0)
ge(0, s(x0))
ge(s(x0), s(x1))
half(0)
half(s(0))
half(s(s(x0)))
get(x0, nil)
get(x0, cons(x1, nil))
get(0, cons(x0, cons(x1, x2)))
get(s(x0), cons(x1, cons(x2, x3)))

We have to consider all minimal (P,Q,R)-chains.
By narrowing [LPAR04] the rule QS(n, cons(x, xs)) → QS(half(n), if1(ge(get(n, cons(x, xs)), x), get(n, cons(x, xs)), x, xs)) at position [1] we obtained the following new rules [LPAR04]:

QS(y0, cons(0, y2)) → QS(half(y0), if1(true, get(y0, cons(0, y2)), 0, y2))
QS(s(x0), cons(x1, cons(x2, x3))) → QS(half(s(x0)), if1(ge(get(x0, cons(x2, x3)), x1), get(s(x0), cons(x1, cons(x2, x3))), x1, cons(x2, x3)))
QS(s(x0), cons(x1, cons(x2, x3))) → QS(half(s(x0)), if1(ge(get(s(x0), cons(x1, cons(x2, x3))), x1), get(x0, cons(x2, x3)), x1, cons(x2, x3)))
QS(x0, cons(x1, nil)) → QS(half(x0), if1(ge(x1, x1), get(x0, cons(x1, nil)), x1, nil))
QS(x0, cons(x1, nil)) → QS(half(x0), if1(ge(get(x0, cons(x1, nil)), x1), x1, x1, nil))
QS(0, cons(x0, cons(x1, x2))) → QS(half(0), if1(ge(x0, x0), get(0, cons(x0, cons(x1, x2))), x0, cons(x1, x2)))
QS(0, cons(x0, cons(x1, x2))) → QS(half(0), if1(ge(get(0, cons(x0, cons(x1, x2))), x0), x0, x0, cons(x1, x2)))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Rewriting

                          ↳ QDP

                            ↳ Rewriting

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Rewriting

                                                      ↳ QDP

                                                        ↳ Rewriting

                                                          ↳ QDP

                                                            ↳ Rewriting

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

QS(x0, cons(x1, nil)) → QS(half(x0), if2(ge(x1, x1), x1, x1, nil))
QS(s(x0), cons(x1, cons(x2, x3))) → QS(half(s(x0)), if2(ge(x1, get(x0, cons(x2, x3))), get(x0, cons(x2, x3)), x1, cons(x2, x3)))
QS(0, cons(x0, cons(x1, x2))) → QS(0, if2(ge(x0, x0), x0, x0, cons(x1, x2)))
QS(y0, cons(0, y2)) → QS(half(y0), if1(true, get(y0, cons(0, y2)), 0, y2))
QS(s(x0), cons(x1, cons(x2, x3))) → QS(half(s(x0)), if1(ge(get(x0, cons(x2, x3)), x1), get(s(x0), cons(x1, cons(x2, x3))), x1, cons(x2, x3)))
QS(s(x0), cons(x1, cons(x2, x3))) → QS(half(s(x0)), if1(ge(get(s(x0), cons(x1, cons(x2, x3))), x1), get(x0, cons(x2, x3)), x1, cons(x2, x3)))
QS(x0, cons(x1, nil)) → QS(half(x0), if1(ge(x1, x1), get(x0, cons(x1, nil)), x1, nil))
QS(x0, cons(x1, nil)) → QS(half(x0), if1(ge(get(x0, cons(x1, nil)), x1), x1, x1, nil))
QS(0, cons(x0, cons(x1, x2))) → QS(half(0), if1(ge(x0, x0), get(0, cons(x0, cons(x1, x2))), x0, cons(x1, x2)))
QS(0, cons(x0, cons(x1, x2))) → QS(half(0), if1(ge(get(0, cons(x0, cons(x1, x2))), x0), x0, x0, cons(x1, x2)))

The TRS R consists of the following rules:

half(0) → 0
half(s(0)) → 0
half(s(s(x))) → s(half(x))
get(n, cons(x, nil)) → x
get(0, cons(x, cons(y, xs))) → x
get(s(n), cons(x, cons(y, xs))) → get(n, cons(y, xs))
if2(true, n, x, xs) → filterhigh(n, xs)
filterhigh(n, cons(x, xs)) → if2(ge(x, n), n, x, xs)
ge(x, 0) → true
ge(0, s(x)) → false
ge(s(x), s(y)) → ge(x, y)
if2(false, n, x, xs) → cons(x, filterhigh(n, xs))
filterhigh(n, nil) → nil
if1(true, n, x, xs) → filterlow(n, xs)
filterlow(n, cons(x, xs)) → if1(ge(n, x), n, x, xs)
if1(false, n, x, xs) → cons(x, filterlow(n, xs))
filterlow(n, nil) → nil

The set Q consists of the following terms:

filterlow(x0, nil)
filterlow(x0, cons(x1, x2))
if1(true, x0, x1, x2)
if1(false, x0, x1, x2)
filterhigh(x0, nil)
filterhigh(x0, cons(x1, x2))
if2(true, x0, x1, x2)
if2(false, x0, x1, x2)
ge(x0, 0)
ge(0, s(x0))
ge(s(x0), s(x1))
half(0)
half(s(0))
half(s(s(x0)))
get(x0, nil)
get(x0, cons(x1, nil))
get(0, cons(x0, cons(x1, x2)))
get(s(x0), cons(x1, cons(x2, x3)))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule QS(y0, cons(0, y2)) → QS(half(y0), if1(true, get(y0, cons(0, y2)), 0, y2)) at position [1] we obtained the following new rules [LPAR04]:

QS(y0, cons(0, y2)) → QS(half(y0), filterlow(get(y0, cons(0, y2)), y2))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Rewriting

                          ↳ QDP

                            ↳ Rewriting

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Rewriting

                                                      ↳ QDP

                                                        ↳ Rewriting

                                                          ↳ QDP

                                                            ↳ Rewriting

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ Rewriting

                                                                          ↳ QDP

                                                                            ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

QS(x0, cons(x1, nil)) → QS(half(x0), if2(ge(x1, x1), x1, x1, nil))
QS(s(x0), cons(x1, cons(x2, x3))) → QS(half(s(x0)), if2(ge(x1, get(x0, cons(x2, x3))), get(x0, cons(x2, x3)), x1, cons(x2, x3)))
QS(0, cons(x0, cons(x1, x2))) → QS(0, if2(ge(x0, x0), x0, x0, cons(x1, x2)))
QS(s(x0), cons(x1, cons(x2, x3))) → QS(half(s(x0)), if1(ge(get(x0, cons(x2, x3)), x1), get(s(x0), cons(x1, cons(x2, x3))), x1, cons(x2, x3)))
QS(s(x0), cons(x1, cons(x2, x3))) → QS(half(s(x0)), if1(ge(get(s(x0), cons(x1, cons(x2, x3))), x1), get(x0, cons(x2, x3)), x1, cons(x2, x3)))
QS(x0, cons(x1, nil)) → QS(half(x0), if1(ge(x1, x1), get(x0, cons(x1, nil)), x1, nil))
QS(x0, cons(x1, nil)) → QS(half(x0), if1(ge(get(x0, cons(x1, nil)), x1), x1, x1, nil))
QS(0, cons(x0, cons(x1, x2))) → QS(half(0), if1(ge(x0, x0), get(0, cons(x0, cons(x1, x2))), x0, cons(x1, x2)))
QS(0, cons(x0, cons(x1, x2))) → QS(half(0), if1(ge(get(0, cons(x0, cons(x1, x2))), x0), x0, x0, cons(x1, x2)))
QS(y0, cons(0, y2)) → QS(half(y0), filterlow(get(y0, cons(0, y2)), y2))

The TRS R consists of the following rules:

half(0) → 0
half(s(0)) → 0
half(s(s(x))) → s(half(x))
get(n, cons(x, nil)) → x
get(0, cons(x, cons(y, xs))) → x
get(s(n), cons(x, cons(y, xs))) → get(n, cons(y, xs))
if2(true, n, x, xs) → filterhigh(n, xs)
filterhigh(n, cons(x, xs)) → if2(ge(x, n), n, x, xs)
ge(x, 0) → true
ge(0, s(x)) → false
ge(s(x), s(y)) → ge(x, y)
if2(false, n, x, xs) → cons(x, filterhigh(n, xs))
filterhigh(n, nil) → nil
if1(true, n, x, xs) → filterlow(n, xs)
filterlow(n, cons(x, xs)) → if1(ge(n, x), n, x, xs)
if1(false, n, x, xs) → cons(x, filterlow(n, xs))
filterlow(n, nil) → nil

The set Q consists of the following terms:

filterlow(x0, nil)
filterlow(x0, cons(x1, x2))
if1(true, x0, x1, x2)
if1(false, x0, x1, x2)
filterhigh(x0, nil)
filterhigh(x0, cons(x1, x2))
if2(true, x0, x1, x2)
if2(false, x0, x1, x2)
ge(x0, 0)
ge(0, s(x0))
ge(s(x0), s(x1))
half(0)
half(s(0))
half(s(s(x0)))
get(x0, nil)
get(x0, cons(x1, nil))
get(0, cons(x0, cons(x1, x2)))
get(s(x0), cons(x1, cons(x2, x3)))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule QS(s(x0), cons(x1, cons(x2, x3))) → QS(half(s(x0)), if1(ge(get(x0, cons(x2, x3)), x1), get(s(x0), cons(x1, cons(x2, x3))), x1, cons(x2, x3))) at position [1,1] we obtained the following new rules [LPAR04]:

QS(s(x0), cons(x1, cons(x2, x3))) → QS(half(s(x0)), if1(ge(get(x0, cons(x2, x3)), x1), get(x0, cons(x2, x3)), x1, cons(x2, x3)))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Rewriting

                          ↳ QDP

                            ↳ Rewriting

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Rewriting

                                                      ↳ QDP

                                                        ↳ Rewriting

                                                          ↳ QDP

                                                            ↳ Rewriting

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ Rewriting

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

QS(x0, cons(x1, nil)) → QS(half(x0), if2(ge(x1, x1), x1, x1, nil))
QS(s(x0), cons(x1, cons(x2, x3))) → QS(half(s(x0)), if2(ge(x1, get(x0, cons(x2, x3))), get(x0, cons(x2, x3)), x1, cons(x2, x3)))
QS(0, cons(x0, cons(x1, x2))) → QS(0, if2(ge(x0, x0), x0, x0, cons(x1, x2)))
QS(s(x0), cons(x1, cons(x2, x3))) → QS(half(s(x0)), if1(ge(get(s(x0), cons(x1, cons(x2, x3))), x1), get(x0, cons(x2, x3)), x1, cons(x2, x3)))
QS(x0, cons(x1, nil)) → QS(half(x0), if1(ge(x1, x1), get(x0, cons(x1, nil)), x1, nil))
QS(x0, cons(x1, nil)) → QS(half(x0), if1(ge(get(x0, cons(x1, nil)), x1), x1, x1, nil))
QS(0, cons(x0, cons(x1, x2))) → QS(half(0), if1(ge(x0, x0), get(0, cons(x0, cons(x1, x2))), x0, cons(x1, x2)))
QS(0, cons(x0, cons(x1, x2))) → QS(half(0), if1(ge(get(0, cons(x0, cons(x1, x2))), x0), x0, x0, cons(x1, x2)))
QS(y0, cons(0, y2)) → QS(half(y0), filterlow(get(y0, cons(0, y2)), y2))
QS(s(x0), cons(x1, cons(x2, x3))) → QS(half(s(x0)), if1(ge(get(x0, cons(x2, x3)), x1), get(x0, cons(x2, x3)), x1, cons(x2, x3)))

The TRS R consists of the following rules:

half(0) → 0
half(s(0)) → 0
half(s(s(x))) → s(half(x))
get(n, cons(x, nil)) → x
get(0, cons(x, cons(y, xs))) → x
get(s(n), cons(x, cons(y, xs))) → get(n, cons(y, xs))
if2(true, n, x, xs) → filterhigh(n, xs)
filterhigh(n, cons(x, xs)) → if2(ge(x, n), n, x, xs)
ge(x, 0) → true
ge(0, s(x)) → false
ge(s(x), s(y)) → ge(x, y)
if2(false, n, x, xs) → cons(x, filterhigh(n, xs))
filterhigh(n, nil) → nil
if1(true, n, x, xs) → filterlow(n, xs)
filterlow(n, cons(x, xs)) → if1(ge(n, x), n, x, xs)
if1(false, n, x, xs) → cons(x, filterlow(n, xs))
filterlow(n, nil) → nil

The set Q consists of the following terms:

filterlow(x0, nil)
filterlow(x0, cons(x1, x2))
if1(true, x0, x1, x2)
if1(false, x0, x1, x2)
filterhigh(x0, nil)
filterhigh(x0, cons(x1, x2))
if2(true, x0, x1, x2)
if2(false, x0, x1, x2)
ge(x0, 0)
ge(0, s(x0))
ge(s(x0), s(x1))
half(0)
half(s(0))
half(s(s(x0)))
get(x0, nil)
get(x0, cons(x1, nil))
get(0, cons(x0, cons(x1, x2)))
get(s(x0), cons(x1, cons(x2, x3)))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule QS(s(x0), cons(x1, cons(x2, x3))) → QS(half(s(x0)), if1(ge(get(s(x0), cons(x1, cons(x2, x3))), x1), get(x0, cons(x2, x3)), x1, cons(x2, x3))) at position [1,0,0] we obtained the following new rules [LPAR04]:

QS(s(x0), cons(x1, cons(x2, x3))) → QS(half(s(x0)), if1(ge(get(x0, cons(x2, x3)), x1), get(x0, cons(x2, x3)), x1, cons(x2, x3)))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Rewriting

                          ↳ QDP

                            ↳ Rewriting

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Rewriting

                                                      ↳ QDP

                                                        ↳ Rewriting

                                                          ↳ QDP

                                                            ↳ Rewriting

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ Rewriting

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

QS(x0, cons(x1, nil)) → QS(half(x0), if2(ge(x1, x1), x1, x1, nil))
QS(s(x0), cons(x1, cons(x2, x3))) → QS(half(s(x0)), if2(ge(x1, get(x0, cons(x2, x3))), get(x0, cons(x2, x3)), x1, cons(x2, x3)))
QS(0, cons(x0, cons(x1, x2))) → QS(0, if2(ge(x0, x0), x0, x0, cons(x1, x2)))
QS(x0, cons(x1, nil)) → QS(half(x0), if1(ge(x1, x1), get(x0, cons(x1, nil)), x1, nil))
QS(x0, cons(x1, nil)) → QS(half(x0), if1(ge(get(x0, cons(x1, nil)), x1), x1, x1, nil))
QS(0, cons(x0, cons(x1, x2))) → QS(half(0), if1(ge(x0, x0), get(0, cons(x0, cons(x1, x2))), x0, cons(x1, x2)))
QS(0, cons(x0, cons(x1, x2))) → QS(half(0), if1(ge(get(0, cons(x0, cons(x1, x2))), x0), x0, x0, cons(x1, x2)))
QS(y0, cons(0, y2)) → QS(half(y0), filterlow(get(y0, cons(0, y2)), y2))
QS(s(x0), cons(x1, cons(x2, x3))) → QS(half(s(x0)), if1(ge(get(x0, cons(x2, x3)), x1), get(x0, cons(x2, x3)), x1, cons(x2, x3)))

The TRS R consists of the following rules:

half(0) → 0
half(s(0)) → 0
half(s(s(x))) → s(half(x))
get(n, cons(x, nil)) → x
get(0, cons(x, cons(y, xs))) → x
get(s(n), cons(x, cons(y, xs))) → get(n, cons(y, xs))
if2(true, n, x, xs) → filterhigh(n, xs)
filterhigh(n, cons(x, xs)) → if2(ge(x, n), n, x, xs)
ge(x, 0) → true
ge(0, s(x)) → false
ge(s(x), s(y)) → ge(x, y)
if2(false, n, x, xs) → cons(x, filterhigh(n, xs))
filterhigh(n, nil) → nil
if1(true, n, x, xs) → filterlow(n, xs)
filterlow(n, cons(x, xs)) → if1(ge(n, x), n, x, xs)
if1(false, n, x, xs) → cons(x, filterlow(n, xs))
filterlow(n, nil) → nil

The set Q consists of the following terms:

filterlow(x0, nil)
filterlow(x0, cons(x1, x2))
if1(true, x0, x1, x2)
if1(false, x0, x1, x2)
filterhigh(x0, nil)
filterhigh(x0, cons(x1, x2))
if2(true, x0, x1, x2)
if2(false, x0, x1, x2)
ge(x0, 0)
ge(0, s(x0))
ge(s(x0), s(x1))
half(0)
half(s(0))
half(s(s(x0)))
get(x0, nil)
get(x0, cons(x1, nil))
get(0, cons(x0, cons(x1, x2)))
get(s(x0), cons(x1, cons(x2, x3)))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule QS(x0, cons(x1, nil)) → QS(half(x0), if1(ge(x1, x1), get(x0, cons(x1, nil)), x1, nil)) at position [1,1] we obtained the following new rules [LPAR04]:

QS(x0, cons(x1, nil)) → QS(half(x0), if1(ge(x1, x1), x1, x1, nil))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Rewriting

                          ↳ QDP

                            ↳ Rewriting

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Rewriting

                                                      ↳ QDP

                                                        ↳ Rewriting

                                                          ↳ QDP

                                                            ↳ Rewriting

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ Rewriting

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

QS(x0, cons(x1, nil)) → QS(half(x0), if2(ge(x1, x1), x1, x1, nil))
QS(s(x0), cons(x1, cons(x2, x3))) → QS(half(s(x0)), if2(ge(x1, get(x0, cons(x2, x3))), get(x0, cons(x2, x3)), x1, cons(x2, x3)))
QS(0, cons(x0, cons(x1, x2))) → QS(0, if2(ge(x0, x0), x0, x0, cons(x1, x2)))
QS(x0, cons(x1, nil)) → QS(half(x0), if1(ge(get(x0, cons(x1, nil)), x1), x1, x1, nil))
QS(0, cons(x0, cons(x1, x2))) → QS(half(0), if1(ge(x0, x0), get(0, cons(x0, cons(x1, x2))), x0, cons(x1, x2)))
QS(0, cons(x0, cons(x1, x2))) → QS(half(0), if1(ge(get(0, cons(x0, cons(x1, x2))), x0), x0, x0, cons(x1, x2)))
QS(y0, cons(0, y2)) → QS(half(y0), filterlow(get(y0, cons(0, y2)), y2))
QS(s(x0), cons(x1, cons(x2, x3))) → QS(half(s(x0)), if1(ge(get(x0, cons(x2, x3)), x1), get(x0, cons(x2, x3)), x1, cons(x2, x3)))
QS(x0, cons(x1, nil)) → QS(half(x0), if1(ge(x1, x1), x1, x1, nil))

The TRS R consists of the following rules:

half(0) → 0
half(s(0)) → 0
half(s(s(x))) → s(half(x))
get(n, cons(x, nil)) → x
get(0, cons(x, cons(y, xs))) → x
get(s(n), cons(x, cons(y, xs))) → get(n, cons(y, xs))
if2(true, n, x, xs) → filterhigh(n, xs)
filterhigh(n, cons(x, xs)) → if2(ge(x, n), n, x, xs)
ge(x, 0) → true
ge(0, s(x)) → false
ge(s(x), s(y)) → ge(x, y)
if2(false, n, x, xs) → cons(x, filterhigh(n, xs))
filterhigh(n, nil) → nil
if1(true, n, x, xs) → filterlow(n, xs)
filterlow(n, cons(x, xs)) → if1(ge(n, x), n, x, xs)
if1(false, n, x, xs) → cons(x, filterlow(n, xs))
filterlow(n, nil) → nil

The set Q consists of the following terms:

filterlow(x0, nil)
filterlow(x0, cons(x1, x2))
if1(true, x0, x1, x2)
if1(false, x0, x1, x2)
filterhigh(x0, nil)
filterhigh(x0, cons(x1, x2))
if2(true, x0, x1, x2)
if2(false, x0, x1, x2)
ge(x0, 0)
ge(0, s(x0))
ge(s(x0), s(x1))
half(0)
half(s(0))
half(s(s(x0)))
get(x0, nil)
get(x0, cons(x1, nil))
get(0, cons(x0, cons(x1, x2)))
get(s(x0), cons(x1, cons(x2, x3)))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule QS(x0, cons(x1, nil)) → QS(half(x0), if1(ge(get(x0, cons(x1, nil)), x1), x1, x1, nil)) at position [1,0,0] we obtained the following new rules [LPAR04]:

QS(x0, cons(x1, nil)) → QS(half(x0), if1(ge(x1, x1), x1, x1, nil))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Rewriting

                          ↳ QDP

                            ↳ Rewriting

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Rewriting

                                                      ↳ QDP

                                                        ↳ Rewriting

                                                          ↳ QDP

                                                            ↳ Rewriting

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ Rewriting

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Rewriting

                                                                                          ↳ QDP

                                                                                            ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

QS(x0, cons(x1, nil)) → QS(half(x0), if2(ge(x1, x1), x1, x1, nil))
QS(s(x0), cons(x1, cons(x2, x3))) → QS(half(s(x0)), if2(ge(x1, get(x0, cons(x2, x3))), get(x0, cons(x2, x3)), x1, cons(x2, x3)))
QS(0, cons(x0, cons(x1, x2))) → QS(0, if2(ge(x0, x0), x0, x0, cons(x1, x2)))
QS(0, cons(x0, cons(x1, x2))) → QS(half(0), if1(ge(x0, x0), get(0, cons(x0, cons(x1, x2))), x0, cons(x1, x2)))
QS(0, cons(x0, cons(x1, x2))) → QS(half(0), if1(ge(get(0, cons(x0, cons(x1, x2))), x0), x0, x0, cons(x1, x2)))
QS(y0, cons(0, y2)) → QS(half(y0), filterlow(get(y0, cons(0, y2)), y2))
QS(s(x0), cons(x1, cons(x2, x3))) → QS(half(s(x0)), if1(ge(get(x0, cons(x2, x3)), x1), get(x0, cons(x2, x3)), x1, cons(x2, x3)))
QS(x0, cons(x1, nil)) → QS(half(x0), if1(ge(x1, x1), x1, x1, nil))

The TRS R consists of the following rules:

half(0) → 0
half(s(0)) → 0
half(s(s(x))) → s(half(x))
get(n, cons(x, nil)) → x
get(0, cons(x, cons(y, xs))) → x
get(s(n), cons(x, cons(y, xs))) → get(n, cons(y, xs))
if2(true, n, x, xs) → filterhigh(n, xs)
filterhigh(n, cons(x, xs)) → if2(ge(x, n), n, x, xs)
ge(x, 0) → true
ge(0, s(x)) → false
ge(s(x), s(y)) → ge(x, y)
if2(false, n, x, xs) → cons(x, filterhigh(n, xs))
filterhigh(n, nil) → nil
if1(true, n, x, xs) → filterlow(n, xs)
filterlow(n, cons(x, xs)) → if1(ge(n, x), n, x, xs)
if1(false, n, x, xs) → cons(x, filterlow(n, xs))
filterlow(n, nil) → nil

The set Q consists of the following terms:

filterlow(x0, nil)
filterlow(x0, cons(x1, x2))
if1(true, x0, x1, x2)
if1(false, x0, x1, x2)
filterhigh(x0, nil)
filterhigh(x0, cons(x1, x2))
if2(true, x0, x1, x2)
if2(false, x0, x1, x2)
ge(x0, 0)
ge(0, s(x0))
ge(s(x0), s(x1))
half(0)
half(s(0))
half(s(s(x0)))
get(x0, nil)
get(x0, cons(x1, nil))
get(0, cons(x0, cons(x1, x2)))
get(s(x0), cons(x1, cons(x2, x3)))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule QS(0, cons(x0, cons(x1, x2))) → QS(half(0), if1(ge(x0, x0), get(0, cons(x0, cons(x1, x2))), x0, cons(x1, x2))) at position [0] we obtained the following new rules [LPAR04]:

QS(0, cons(x0, cons(x1, x2))) → QS(0, if1(ge(x0, x0), get(0, cons(x0, cons(x1, x2))), x0, cons(x1, x2)))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Rewriting

                          ↳ QDP

                            ↳ Rewriting

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Rewriting

                                                      ↳ QDP

                                                        ↳ Rewriting

                                                          ↳ QDP

                                                            ↳ Rewriting

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ Rewriting

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Rewriting

                                                                                          ↳ QDP

                                                                                            ↳ Rewriting

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

QS(x0, cons(x1, nil)) → QS(half(x0), if2(ge(x1, x1), x1, x1, nil))
QS(s(x0), cons(x1, cons(x2, x3))) → QS(half(s(x0)), if2(ge(x1, get(x0, cons(x2, x3))), get(x0, cons(x2, x3)), x1, cons(x2, x3)))
QS(0, cons(x0, cons(x1, x2))) → QS(0, if2(ge(x0, x0), x0, x0, cons(x1, x2)))
QS(0, cons(x0, cons(x1, x2))) → QS(half(0), if1(ge(get(0, cons(x0, cons(x1, x2))), x0), x0, x0, cons(x1, x2)))
QS(y0, cons(0, y2)) → QS(half(y0), filterlow(get(y0, cons(0, y2)), y2))
QS(s(x0), cons(x1, cons(x2, x3))) → QS(half(s(x0)), if1(ge(get(x0, cons(x2, x3)), x1), get(x0, cons(x2, x3)), x1, cons(x2, x3)))
QS(x0, cons(x1, nil)) → QS(half(x0), if1(ge(x1, x1), x1, x1, nil))
QS(0, cons(x0, cons(x1, x2))) → QS(0, if1(ge(x0, x0), get(0, cons(x0, cons(x1, x2))), x0, cons(x1, x2)))

The TRS R consists of the following rules:

half(0) → 0
half(s(0)) → 0
half(s(s(x))) → s(half(x))
get(n, cons(x, nil)) → x
get(0, cons(x, cons(y, xs))) → x
get(s(n), cons(x, cons(y, xs))) → get(n, cons(y, xs))
if2(true, n, x, xs) → filterhigh(n, xs)
filterhigh(n, cons(x, xs)) → if2(ge(x, n), n, x, xs)
ge(x, 0) → true
ge(0, s(x)) → false
ge(s(x), s(y)) → ge(x, y)
if2(false, n, x, xs) → cons(x, filterhigh(n, xs))
filterhigh(n, nil) → nil
if1(true, n, x, xs) → filterlow(n, xs)
filterlow(n, cons(x, xs)) → if1(ge(n, x), n, x, xs)
if1(false, n, x, xs) → cons(x, filterlow(n, xs))
filterlow(n, nil) → nil

The set Q consists of the following terms:

filterlow(x0, nil)
filterlow(x0, cons(x1, x2))
if1(true, x0, x1, x2)
if1(false, x0, x1, x2)
filterhigh(x0, nil)
filterhigh(x0, cons(x1, x2))
if2(true, x0, x1, x2)
if2(false, x0, x1, x2)
ge(x0, 0)
ge(0, s(x0))
ge(s(x0), s(x1))
half(0)
half(s(0))
half(s(s(x0)))
get(x0, nil)
get(x0, cons(x1, nil))
get(0, cons(x0, cons(x1, x2)))
get(s(x0), cons(x1, cons(x2, x3)))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule QS(0, cons(x0, cons(x1, x2))) → QS(half(0), if1(ge(get(0, cons(x0, cons(x1, x2))), x0), x0, x0, cons(x1, x2))) at position [0] we obtained the following new rules [LPAR04]:

QS(0, cons(x0, cons(x1, x2))) → QS(0, if1(ge(get(0, cons(x0, cons(x1, x2))), x0), x0, x0, cons(x1, x2)))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Rewriting

                          ↳ QDP

                            ↳ Rewriting

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Rewriting

                                                      ↳ QDP

                                                        ↳ Rewriting

                                                          ↳ QDP

                                                            ↳ Rewriting

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ Rewriting

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Rewriting

                                                                                          ↳ QDP

                                                                                            ↳ Rewriting

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

QS(x0, cons(x1, nil)) → QS(half(x0), if2(ge(x1, x1), x1, x1, nil))
QS(s(x0), cons(x1, cons(x2, x3))) → QS(half(s(x0)), if2(ge(x1, get(x0, cons(x2, x3))), get(x0, cons(x2, x3)), x1, cons(x2, x3)))
QS(0, cons(x0, cons(x1, x2))) → QS(0, if2(ge(x0, x0), x0, x0, cons(x1, x2)))
QS(y0, cons(0, y2)) → QS(half(y0), filterlow(get(y0, cons(0, y2)), y2))
QS(s(x0), cons(x1, cons(x2, x3))) → QS(half(s(x0)), if1(ge(get(x0, cons(x2, x3)), x1), get(x0, cons(x2, x3)), x1, cons(x2, x3)))
QS(x0, cons(x1, nil)) → QS(half(x0), if1(ge(x1, x1), x1, x1, nil))
QS(0, cons(x0, cons(x1, x2))) → QS(0, if1(ge(x0, x0), get(0, cons(x0, cons(x1, x2))), x0, cons(x1, x2)))
QS(0, cons(x0, cons(x1, x2))) → QS(0, if1(ge(get(0, cons(x0, cons(x1, x2))), x0), x0, x0, cons(x1, x2)))

The TRS R consists of the following rules:

half(0) → 0
half(s(0)) → 0
half(s(s(x))) → s(half(x))
get(n, cons(x, nil)) → x
get(0, cons(x, cons(y, xs))) → x
get(s(n), cons(x, cons(y, xs))) → get(n, cons(y, xs))
if2(true, n, x, xs) → filterhigh(n, xs)
filterhigh(n, cons(x, xs)) → if2(ge(x, n), n, x, xs)
ge(x, 0) → true
ge(0, s(x)) → false
ge(s(x), s(y)) → ge(x, y)
if2(false, n, x, xs) → cons(x, filterhigh(n, xs))
filterhigh(n, nil) → nil
if1(true, n, x, xs) → filterlow(n, xs)
filterlow(n, cons(x, xs)) → if1(ge(n, x), n, x, xs)
if1(false, n, x, xs) → cons(x, filterlow(n, xs))
filterlow(n, nil) → nil

The set Q consists of the following terms:

filterlow(x0, nil)
filterlow(x0, cons(x1, x2))
if1(true, x0, x1, x2)
if1(false, x0, x1, x2)
filterhigh(x0, nil)
filterhigh(x0, cons(x1, x2))
if2(true, x0, x1, x2)
if2(false, x0, x1, x2)
ge(x0, 0)
ge(0, s(x0))
ge(s(x0), s(x1))
half(0)
half(s(0))
half(s(s(x0)))
get(x0, nil)
get(x0, cons(x1, nil))
get(0, cons(x0, cons(x1, x2)))
get(s(x0), cons(x1, cons(x2, x3)))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule QS(0, cons(x0, cons(x1, x2))) → QS(0, if1(ge(x0, x0), get(0, cons(x0, cons(x1, x2))), x0, cons(x1, x2))) at position [1,1] we obtained the following new rules [LPAR04]:

QS(0, cons(x0, cons(x1, x2))) → QS(0, if1(ge(x0, x0), x0, x0, cons(x1, x2)))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Rewriting

                          ↳ QDP

                            ↳ Rewriting

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Rewriting

                                                      ↳ QDP

                                                        ↳ Rewriting

                                                          ↳ QDP

                                                            ↳ Rewriting

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ Rewriting

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Rewriting

                                                                                          ↳ QDP

                                                                                            ↳ Rewriting

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

                                                                                                      ↳ QDP

                                                                                                        ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

QS(x0, cons(x1, nil)) → QS(half(x0), if2(ge(x1, x1), x1, x1, nil))
QS(s(x0), cons(x1, cons(x2, x3))) → QS(half(s(x0)), if2(ge(x1, get(x0, cons(x2, x3))), get(x0, cons(x2, x3)), x1, cons(x2, x3)))
QS(0, cons(x0, cons(x1, x2))) → QS(0, if2(ge(x0, x0), x0, x0, cons(x1, x2)))
QS(y0, cons(0, y2)) → QS(half(y0), filterlow(get(y0, cons(0, y2)), y2))
QS(s(x0), cons(x1, cons(x2, x3))) → QS(half(s(x0)), if1(ge(get(x0, cons(x2, x3)), x1), get(x0, cons(x2, x3)), x1, cons(x2, x3)))
QS(x0, cons(x1, nil)) → QS(half(x0), if1(ge(x1, x1), x1, x1, nil))
QS(0, cons(x0, cons(x1, x2))) → QS(0, if1(ge(get(0, cons(x0, cons(x1, x2))), x0), x0, x0, cons(x1, x2)))
QS(0, cons(x0, cons(x1, x2))) → QS(0, if1(ge(x0, x0), x0, x0, cons(x1, x2)))

The TRS R consists of the following rules:

half(0) → 0
half(s(0)) → 0
half(s(s(x))) → s(half(x))
get(n, cons(x, nil)) → x
get(0, cons(x, cons(y, xs))) → x
get(s(n), cons(x, cons(y, xs))) → get(n, cons(y, xs))
if2(true, n, x, xs) → filterhigh(n, xs)
filterhigh(n, cons(x, xs)) → if2(ge(x, n), n, x, xs)
ge(x, 0) → true
ge(0, s(x)) → false
ge(s(x), s(y)) → ge(x, y)
if2(false, n, x, xs) → cons(x, filterhigh(n, xs))
filterhigh(n, nil) → nil
if1(true, n, x, xs) → filterlow(n, xs)
filterlow(n, cons(x, xs)) → if1(ge(n, x), n, x, xs)
if1(false, n, x, xs) → cons(x, filterlow(n, xs))
filterlow(n, nil) → nil

The set Q consists of the following terms:

filterlow(x0, nil)
filterlow(x0, cons(x1, x2))
if1(true, x0, x1, x2)
if1(false, x0, x1, x2)
filterhigh(x0, nil)
filterhigh(x0, cons(x1, x2))
if2(true, x0, x1, x2)
if2(false, x0, x1, x2)
ge(x0, 0)
ge(0, s(x0))
ge(s(x0), s(x1))
half(0)
half(s(0))
half(s(s(x0)))
get(x0, nil)
get(x0, cons(x1, nil))
get(0, cons(x0, cons(x1, x2)))
get(s(x0), cons(x1, cons(x2, x3)))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule QS(0, cons(x0, cons(x1, x2))) → QS(0, if1(ge(get(0, cons(x0, cons(x1, x2))), x0), x0, x0, cons(x1, x2))) at position [1,0,0] we obtained the following new rules [LPAR04]:

QS(0, cons(x0, cons(x1, x2))) → QS(0, if1(ge(x0, x0), x0, x0, cons(x1, x2)))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Rewriting

                          ↳ QDP

                            ↳ Rewriting

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Rewriting

                                                      ↳ QDP

                                                        ↳ Rewriting

                                                          ↳ QDP

                                                            ↳ Rewriting

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ Rewriting

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Rewriting

                                                                                          ↳ QDP

                                                                                            ↳ Rewriting

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

                                                                                                      ↳ QDP

                                                                                                        ↳ Rewriting

                                                                                                          ↳ QDP

                                                                                                            ↳ QDPOrderProof

Q DP problem:
The TRS P consists of the following rules:

QS(x0, cons(x1, nil)) → QS(half(x0), if2(ge(x1, x1), x1, x1, nil))
QS(s(x0), cons(x1, cons(x2, x3))) → QS(half(s(x0)), if2(ge(x1, get(x0, cons(x2, x3))), get(x0, cons(x2, x3)), x1, cons(x2, x3)))
QS(0, cons(x0, cons(x1, x2))) → QS(0, if2(ge(x0, x0), x0, x0, cons(x1, x2)))
QS(y0, cons(0, y2)) → QS(half(y0), filterlow(get(y0, cons(0, y2)), y2))
QS(s(x0), cons(x1, cons(x2, x3))) → QS(half(s(x0)), if1(ge(get(x0, cons(x2, x3)), x1), get(x0, cons(x2, x3)), x1, cons(x2, x3)))
QS(x0, cons(x1, nil)) → QS(half(x0), if1(ge(x1, x1), x1, x1, nil))
QS(0, cons(x0, cons(x1, x2))) → QS(0, if1(ge(x0, x0), x0, x0, cons(x1, x2)))

The TRS R consists of the following rules:

half(0) → 0
half(s(0)) → 0
half(s(s(x))) → s(half(x))
get(n, cons(x, nil)) → x
get(0, cons(x, cons(y, xs))) → x
get(s(n), cons(x, cons(y, xs))) → get(n, cons(y, xs))
if2(true, n, x, xs) → filterhigh(n, xs)
filterhigh(n, cons(x, xs)) → if2(ge(x, n), n, x, xs)
ge(x, 0) → true
ge(0, s(x)) → false
ge(s(x), s(y)) → ge(x, y)
if2(false, n, x, xs) → cons(x, filterhigh(n, xs))
filterhigh(n, nil) → nil
if1(true, n, x, xs) → filterlow(n, xs)
filterlow(n, cons(x, xs)) → if1(ge(n, x), n, x, xs)
if1(false, n, x, xs) → cons(x, filterlow(n, xs))
filterlow(n, nil) → nil

The set Q consists of the following terms:

filterlow(x0, nil)
filterlow(x0, cons(x1, x2))
if1(true, x0, x1, x2)
if1(false, x0, x1, x2)
filterhigh(x0, nil)
filterhigh(x0, cons(x1, x2))
if2(true, x0, x1, x2)
if2(false, x0, x1, x2)
ge(x0, 0)
ge(0, s(x0))
ge(s(x0), s(x1))
half(0)
half(s(0))
half(s(s(x0)))
get(x0, nil)
get(x0, cons(x1, nil))
get(0, cons(x0, cons(x1, x2)))
get(s(x0), cons(x1, cons(x2, x3)))

We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

QS(y0, cons(0, y2)) → QS(half(y0), filterlow(get(y0, cons(0, y2)), y2))

The remaining pairs can at least be oriented weakly.

QS(x0, cons(x1, nil)) → QS(half(x0), if2(ge(x1, x1), x1, x1, nil))
QS(s(x0), cons(x1, cons(x2, x3))) → QS(half(s(x0)), if2(ge(x1, get(x0, cons(x2, x3))), get(x0, cons(x2, x3)), x1, cons(x2, x3)))
QS(0, cons(x0, cons(x1, x2))) → QS(0, if2(ge(x0, x0), x0, x0, cons(x1, x2)))
QS(s(x0), cons(x1, cons(x2, x3))) → QS(half(s(x0)), if1(ge(get(x0, cons(x2, x3)), x1), get(x0, cons(x2, x3)), x1, cons(x2, x3)))
QS(x0, cons(x1, nil)) → QS(half(x0), if1(ge(x1, x1), x1, x1, nil))
QS(0, cons(x0, cons(x1, x2))) → QS(0, if1(ge(x0, x0), x0, x0, cons(x1, x2)))

Used ordering: Polynomial interpretation [POLO]:

POL(0) = 1
POL(QS(x₁, x₂)) = x₂
POL(cons(x₁, x₂)) = x₁ + x₂
POL(false) = 0
POL(filterhigh(x₁, x₂)) = x₂
POL(filterlow(x₁, x₂)) = x₂
POL(ge(x₁, x₂)) = 0
POL(get(x₁, x₂)) = 0
POL(half(x₁)) = 0
POL(if1(x₁, x₂, x₃, x₄)) = x₃ + x₄
POL(if2(x₁, x₂, x₃, x₄)) = x₃ + x₄
POL(nil) = 0
POL(s(x₁)) = 0
POL(true) = 0

The following usable rules [FROCOS05] were oriented:

if2(false, n, x, xs) → cons(x, filterhigh(n, xs))
if2(true, n, x, xs) → filterhigh(n, xs)
filterhigh(n, cons(x, xs)) → if2(ge(x, n), n, x, xs)
filterlow(n, nil) → nil
if1(false, n, x, xs) → cons(x, filterlow(n, xs))
if1(true, n, x, xs) → filterlow(n, xs)
filterlow(n, cons(x, xs)) → if1(ge(n, x), n, x, xs)
filterhigh(n, nil) → nil

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Rewriting

                          ↳ QDP

                            ↳ Rewriting

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Rewriting

                                                      ↳ QDP

                                                        ↳ Rewriting

                                                          ↳ QDP

                                                            ↳ Rewriting

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ Rewriting

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Rewriting

                                                                                          ↳ QDP

                                                                                            ↳ Rewriting

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

                                                                                                      ↳ QDP

                                                                                                        ↳ Rewriting

                                                                                                          ↳ QDP

                                                                                                            ↳ QDPOrderProof

                                                                                                              ↳ QDP

                                                                                                                ↳ QDPOrderProof

Q DP problem:
The TRS P consists of the following rules:

QS(x0, cons(x1, nil)) → QS(half(x0), if2(ge(x1, x1), x1, x1, nil))
QS(s(x0), cons(x1, cons(x2, x3))) → QS(half(s(x0)), if2(ge(x1, get(x0, cons(x2, x3))), get(x0, cons(x2, x3)), x1, cons(x2, x3)))
QS(0, cons(x0, cons(x1, x2))) → QS(0, if2(ge(x0, x0), x0, x0, cons(x1, x2)))
QS(s(x0), cons(x1, cons(x2, x3))) → QS(half(s(x0)), if1(ge(get(x0, cons(x2, x3)), x1), get(x0, cons(x2, x3)), x1, cons(x2, x3)))
QS(x0, cons(x1, nil)) → QS(half(x0), if1(ge(x1, x1), x1, x1, nil))
QS(0, cons(x0, cons(x1, x2))) → QS(0, if1(ge(x0, x0), x0, x0, cons(x1, x2)))

The TRS R consists of the following rules:

half(0) → 0
half(s(0)) → 0
half(s(s(x))) → s(half(x))
get(n, cons(x, nil)) → x
get(0, cons(x, cons(y, xs))) → x
get(s(n), cons(x, cons(y, xs))) → get(n, cons(y, xs))
if2(true, n, x, xs) → filterhigh(n, xs)
filterhigh(n, cons(x, xs)) → if2(ge(x, n), n, x, xs)
ge(x, 0) → true
ge(0, s(x)) → false
ge(s(x), s(y)) → ge(x, y)
if2(false, n, x, xs) → cons(x, filterhigh(n, xs))
filterhigh(n, nil) → nil
if1(true, n, x, xs) → filterlow(n, xs)
filterlow(n, cons(x, xs)) → if1(ge(n, x), n, x, xs)
if1(false, n, x, xs) → cons(x, filterlow(n, xs))
filterlow(n, nil) → nil

The set Q consists of the following terms:

filterlow(x0, nil)
filterlow(x0, cons(x1, x2))
if1(true, x0, x1, x2)
if1(false, x0, x1, x2)
filterhigh(x0, nil)
filterhigh(x0, cons(x1, x2))
if2(true, x0, x1, x2)
if2(false, x0, x1, x2)
ge(x0, 0)
ge(0, s(x0))
ge(s(x0), s(x1))
half(0)
half(s(0))
half(s(s(x0)))
get(x0, nil)
get(x0, cons(x1, nil))
get(0, cons(x0, cons(x1, x2)))
get(s(x0), cons(x1, cons(x2, x3)))

We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

QS(s(x0), cons(x1, cons(x2, x3))) → QS(half(s(x0)), if2(ge(x1, get(x0, cons(x2, x3))), get(x0, cons(x2, x3)), x1, cons(x2, x3)))
QS(s(x0), cons(x1, cons(x2, x3))) → QS(half(s(x0)), if1(ge(get(x0, cons(x2, x3)), x1), get(x0, cons(x2, x3)), x1, cons(x2, x3)))

The remaining pairs can at least be oriented weakly.

QS(x0, cons(x1, nil)) → QS(half(x0), if2(ge(x1, x1), x1, x1, nil))
QS(0, cons(x0, cons(x1, x2))) → QS(0, if2(ge(x0, x0), x0, x0, cons(x1, x2)))
QS(x0, cons(x1, nil)) → QS(half(x0), if1(ge(x1, x1), x1, x1, nil))
QS(0, cons(x0, cons(x1, x2))) → QS(0, if1(ge(x0, x0), x0, x0, cons(x1, x2)))

Used ordering: Polynomial interpretation [POLO,RATPOLO]:

POL(if2(x₁, x₂, x₃, x₄)) = (13/4)x₃
POL(get(x₁, x₂)) = 3/2 + (4)x₁ + x₂
POL(true) = 0
POL(filterhigh(x₁, x₂)) = 7/2 + (3/4)x₁
POL(0) = 0
POL(cons(x₁, x₂)) = 0
POL(half(x₁)) = (1/4)x₁
POL(false) = 0
POL(filterlow(x₁, x₂)) = 9/4 + (15/4)x₁ + x₂
POL(s(x₁)) = 4 + (4)x₁
POL(QS(x₁, x₂)) = (1/4)x₁
POL(if1(x₁, x₂, x₃, x₄)) = (1/4)x₁
POL(ge(x₁, x₂)) = 4
POL(nil) = 0

The value of delta used in the strict ordering is 3/4.
The following usable rules [FROCOS05] were oriented:

half(s(s(x))) → s(half(x))
half(0) → 0
half(s(0)) → 0

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Rewriting

                          ↳ QDP

                            ↳ Rewriting

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Rewriting

                                                      ↳ QDP

                                                        ↳ Rewriting

                                                          ↳ QDP

                                                            ↳ Rewriting

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ Rewriting

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Rewriting

                                                                                          ↳ QDP

                                                                                            ↳ Rewriting

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

                                                                                                      ↳ QDP

                                                                                                        ↳ Rewriting

                                                                                                          ↳ QDP

                                                                                                            ↳ QDPOrderProof

                                                                                                              ↳ QDP

                                                                                                                ↳ QDPOrderProof

                                                                                                                  ↳ QDP

                                                                                                                    ↳ UsableRulesProof

Q DP problem:
The TRS P consists of the following rules:

QS(x0, cons(x1, nil)) → QS(half(x0), if2(ge(x1, x1), x1, x1, nil))
QS(0, cons(x0, cons(x1, x2))) → QS(0, if2(ge(x0, x0), x0, x0, cons(x1, x2)))
QS(x0, cons(x1, nil)) → QS(half(x0), if1(ge(x1, x1), x1, x1, nil))
QS(0, cons(x0, cons(x1, x2))) → QS(0, if1(ge(x0, x0), x0, x0, cons(x1, x2)))

The TRS R consists of the following rules:

half(0) → 0
half(s(0)) → 0
half(s(s(x))) → s(half(x))
get(n, cons(x, nil)) → x
get(0, cons(x, cons(y, xs))) → x
get(s(n), cons(x, cons(y, xs))) → get(n, cons(y, xs))
if2(true, n, x, xs) → filterhigh(n, xs)
filterhigh(n, cons(x, xs)) → if2(ge(x, n), n, x, xs)
ge(x, 0) → true
ge(0, s(x)) → false
ge(s(x), s(y)) → ge(x, y)
if2(false, n, x, xs) → cons(x, filterhigh(n, xs))
filterhigh(n, nil) → nil
if1(true, n, x, xs) → filterlow(n, xs)
filterlow(n, cons(x, xs)) → if1(ge(n, x), n, x, xs)
if1(false, n, x, xs) → cons(x, filterlow(n, xs))
filterlow(n, nil) → nil

The set Q consists of the following terms:

filterlow(x0, nil)
filterlow(x0, cons(x1, x2))
if1(true, x0, x1, x2)
if1(false, x0, x1, x2)
filterhigh(x0, nil)
filterhigh(x0, cons(x1, x2))
if2(true, x0, x1, x2)
if2(false, x0, x1, x2)
ge(x0, 0)
ge(0, s(x0))
ge(s(x0), s(x1))
half(0)
half(s(0))
half(s(s(x0)))
get(x0, nil)
get(x0, cons(x1, nil))
get(0, cons(x0, cons(x1, x2)))
get(s(x0), cons(x1, cons(x2, x3)))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Rewriting

                          ↳ QDP

                            ↳ Rewriting

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Rewriting

                                                      ↳ QDP

                                                        ↳ Rewriting

                                                          ↳ QDP

                                                            ↳ Rewriting

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ Rewriting

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Rewriting

                                                                                          ↳ QDP

                                                                                            ↳ Rewriting

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

                                                                                                      ↳ QDP

                                                                                                        ↳ Rewriting

                                                                                                          ↳ QDP

                                                                                                            ↳ QDPOrderProof

                                                                                                              ↳ QDP

                                                                                                                ↳ QDPOrderProof

                                                                                                                  ↳ QDP

                                                                                                                    ↳ UsableRulesProof

                                                                                                                      ↳ QDP

                                                                                                                        ↳ QReductionProof

Q DP problem:
The TRS P consists of the following rules:

QS(x0, cons(x1, nil)) → QS(half(x0), if2(ge(x1, x1), x1, x1, nil))
QS(0, cons(x0, cons(x1, x2))) → QS(0, if2(ge(x0, x0), x0, x0, cons(x1, x2)))
QS(x0, cons(x1, nil)) → QS(half(x0), if1(ge(x1, x1), x1, x1, nil))
QS(0, cons(x0, cons(x1, x2))) → QS(0, if1(ge(x0, x0), x0, x0, cons(x1, x2)))

The TRS R consists of the following rules:

ge(x, 0) → true
ge(s(x), s(y)) → ge(x, y)
if1(true, n, x, xs) → filterlow(n, xs)
filterlow(n, cons(x, xs)) → if1(ge(n, x), n, x, xs)
if1(false, n, x, xs) → cons(x, filterlow(n, xs))
filterlow(n, nil) → nil
ge(0, s(x)) → false
half(0) → 0
half(s(0)) → 0
half(s(s(x))) → s(half(x))
if2(true, n, x, xs) → filterhigh(n, xs)
filterhigh(n, cons(x, xs)) → if2(ge(x, n), n, x, xs)
if2(false, n, x, xs) → cons(x, filterhigh(n, xs))
filterhigh(n, nil) → nil

The set Q consists of the following terms:

filterlow(x0, nil)
filterlow(x0, cons(x1, x2))
if1(true, x0, x1, x2)
if1(false, x0, x1, x2)
filterhigh(x0, nil)
filterhigh(x0, cons(x1, x2))
if2(true, x0, x1, x2)
if2(false, x0, x1, x2)
ge(x0, 0)
ge(0, s(x0))
ge(s(x0), s(x1))
half(0)
half(s(0))
half(s(s(x0)))
get(x0, nil)
get(x0, cons(x1, nil))
get(0, cons(x0, cons(x1, x2)))
get(s(x0), cons(x1, cons(x2, x3)))

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN].

get(x0, nil)
get(x0, cons(x1, nil))
get(0, cons(x0, cons(x1, x2)))
get(s(x0), cons(x1, cons(x2, x3)))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Rewriting

                          ↳ QDP

                            ↳ Rewriting

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Rewriting

                                                      ↳ QDP

                                                        ↳ Rewriting

                                                          ↳ QDP

                                                            ↳ Rewriting

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ Rewriting

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Rewriting

                                                                                          ↳ QDP

                                                                                            ↳ Rewriting

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

                                                                                                      ↳ QDP

                                                                                                        ↳ Rewriting

                                                                                                          ↳ QDP

                                                                                                            ↳ QDPOrderProof

                                                                                                              ↳ QDP

                                                                                                                ↳ QDPOrderProof

                                                                                                                  ↳ QDP

                                                                                                                    ↳ UsableRulesProof

                                                                                                                      ↳ QDP

                                                                                                                        ↳ QReductionProof

                                                                                                                          ↳ QDP

                                                                                                                            ↳ Induction-Processor

Q DP problem:
The TRS P consists of the following rules:

QS(x0, cons(x1, nil)) → QS(half(x0), if2(ge(x1, x1), x1, x1, nil))
QS(0, cons(x0, cons(x1, x2))) → QS(0, if2(ge(x0, x0), x0, x0, cons(x1, x2)))
QS(x0, cons(x1, nil)) → QS(half(x0), if1(ge(x1, x1), x1, x1, nil))
QS(0, cons(x0, cons(x1, x2))) → QS(0, if1(ge(x0, x0), x0, x0, cons(x1, x2)))

The TRS R consists of the following rules:

ge(x, 0) → true
ge(s(x), s(y)) → ge(x, y)
if1(true, n, x, xs) → filterlow(n, xs)
filterlow(n, cons(x, xs)) → if1(ge(n, x), n, x, xs)
if1(false, n, x, xs) → cons(x, filterlow(n, xs))
filterlow(n, nil) → nil
ge(0, s(x)) → false
half(0) → 0
half(s(0)) → 0
half(s(s(x))) → s(half(x))
if2(true, n, x, xs) → filterhigh(n, xs)
filterhigh(n, cons(x, xs)) → if2(ge(x, n), n, x, xs)
if2(false, n, x, xs) → cons(x, filterhigh(n, xs))
filterhigh(n, nil) → nil

The set Q consists of the following terms:

filterlow(x0, nil)
filterlow(x0, cons(x1, x2))
if1(true, x0, x1, x2)
if1(false, x0, x1, x2)
filterhigh(x0, nil)
filterhigh(x0, cons(x1, x2))
if2(true, x0, x1, x2)
if2(false, x0, x1, x2)
ge(x0, 0)
ge(0, s(x0))
ge(s(x0), s(x1))
half(0)
half(s(0))
half(s(s(x0)))

We have to consider all minimal (P,Q,R)-chains.

This DP could be deleted by the Induction-Processor:
QS(x0', cons(x1', nil)) → QS(half(x0'), if2(ge(x1', x1'), x1', x1', nil))

This order was computed:
Polynomial interpretation [POLO]:

POL(0) = 0
POL(QS(x₁, x₂)) = x₂
POL(cons(x₁, x₂)) = 1 + x₂
POL(false) = 0
POL(filterhigh(x₁, x₂)) = x₂
POL(filterlow(x₁, x₂)) = x₂
POL(ge(x₁, x₂)) = 1
POL(half(x₁)) = 0
POL(if1(x₁, x₂, x₃, x₄)) = 1 + x₄
POL(if2(x₁, x₂, x₃, x₄)) = 1 + x₄
POL(nil) = 0
POL(s(x₁)) = 0
POL(true) = 1

At least one of these decreasing rules is always used after the deleted DP:
if2(true, n824, x1054, xs614) → filterhigh(n824, xs614)

The following formula is valid:
x1':sort[a0].if2'(ge(x1' , x1' ), x1' , x1' , nil)=true

The transformed set:
if2'(true, n82, x105, xs61) → true
filterhigh'(n91, cons(x116, xs68)) → if2'(ge(x116, n91), n91, x116, xs68)
if2'(false, n100, x127, xs75) → filterhigh'(n100, xs75)
filterhigh'(n109, nil) → false
ge(x', 0) → true
ge(s(x9), s(y'')) → ge(x9, y'')
if1(true, n14, x20, xs10) → filterlow(n14, xs10)
filterlow(n23, cons(x31, xs17)) → if1(ge(n23, x31), n23, x31, xs17)
if1(false, n32, x42, xs24) → cons(x42, filterlow(n32, xs24))
filterlow(n41, nil) → nil
ge(0, s(x63)) → false
half(0) → 0
half(s(0)) → 0
half(s(s(x94))) → s(half(x94))
if2(true, n82, x105, xs61) → filterhigh(n82, xs61)
filterhigh(n91, cons(x116, xs68)) → if2(ge(x116, n91), n91, x116, xs68)
if2(false, n100, x127, xs75) → cons(x127, filterhigh(n100, xs75))
filterhigh(n109, nil) → nil
equal_bool(true, false) → false
equal_bool(false, true) → false
equal_bool(true, true) → true
equal_bool(false, false) → true
and(true, x) → x
and(false, x) → false
or(true, x) → true
or(false, x) → x
not(false) → true
not(true) → false
isa_true(true) → true
isa_true(false) → false
isa_false(true) → false
isa_false(false) → true
equal_sort[a0](0, 0) → true
equal_sort[a0](0, s(x0)) → false
equal_sort[a0](s(x0), 0) → false
equal_sort[a0](s(x0), s(x1)) → equal_sort[a0](x0, x1)
equal_sort[a5](nil, nil) → true
equal_sort[a5](nil, cons(x0, x1)) → false
equal_sort[a5](cons(x0, x1), nil) → false
equal_sort[a5](cons(x0, x1), cons(x2, x3)) → and(equal_sort[a5](x0, x2), equal_sort[a5](x1, x3))
equal_sort[a67](witness_sort[a67], witness_sort[a67]) → true

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Rewriting

                          ↳ QDP

                            ↳ Rewriting

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Rewriting

                                                      ↳ QDP

                                                        ↳ Rewriting

                                                          ↳ QDP

                                                            ↳ Rewriting

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ Rewriting

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Rewriting

                                                                                          ↳ QDP

                                                                                            ↳ Rewriting

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

                                                                                                      ↳ QDP

                                                                                                        ↳ Rewriting

                                                                                                          ↳ QDP

                                                                                                            ↳ QDPOrderProof

                                                                                                              ↳ QDP

                                                                                                                ↳ QDPOrderProof

                                                                                                                  ↳ QDP

                                                                                                                    ↳ UsableRulesProof

                                                                                                                      ↳ QDP

                                                                                                                        ↳ QReductionProof

                                                                                                                          ↳ QDP

                                                                                                                            ↳ Induction-Processor

                                                                                                                              ↳ AND

                                                                                                                                ↳ QDP

                                                                                                                                  ↳ Induction-Processor

                                                                                                                                ↳ QTRS

Q DP problem:
The TRS P consists of the following rules:

QS(0, cons(x0, cons(x1, x2))) → QS(0, if2(ge(x0, x0), x0, x0, cons(x1, x2)))
QS(x0, cons(x1, nil)) → QS(half(x0), if1(ge(x1, x1), x1, x1, nil))
QS(0, cons(x0, cons(x1, x2))) → QS(0, if1(ge(x0, x0), x0, x0, cons(x1, x2)))

The TRS R consists of the following rules:

ge(x, 0) → true
ge(s(x), s(y)) → ge(x, y)
if1(true, n, x, xs) → filterlow(n, xs)
filterlow(n, cons(x, xs)) → if1(ge(n, x), n, x, xs)
if1(false, n, x, xs) → cons(x, filterlow(n, xs))
filterlow(n, nil) → nil
ge(0, s(x)) → false
half(0) → 0
half(s(0)) → 0
half(s(s(x))) → s(half(x))
if2(true, n, x, xs) → filterhigh(n, xs)
filterhigh(n, cons(x, xs)) → if2(ge(x, n), n, x, xs)
if2(false, n, x, xs) → cons(x, filterhigh(n, xs))
filterhigh(n, nil) → nil

The set Q consists of the following terms:

filterlow(x0, nil)
filterlow(x0, cons(x1, x2))
if1(true, x0, x1, x2)
if1(false, x0, x1, x2)
filterhigh(x0, nil)
filterhigh(x0, cons(x1, x2))
if2(true, x0, x1, x2)
if2(false, x0, x1, x2)
ge(x0, 0)
ge(0, s(x0))
ge(s(x0), s(x1))
half(0)
half(s(0))
half(s(s(x0)))

We have to consider all minimal (P,Q,R)-chains.

This DP could be deleted by the Induction-Processor:
QS(0, cons(x0', cons(x1', x2'))) → QS(0, if2(ge(x0', x0'), x0', x0', cons(x1', x2')))

This order was computed:
Polynomial interpretation [POLO]:

POL(0) = 0
POL(QS(x₁, x₂)) = x₂
POL(cons(x₁, x₂)) = 1 + x₂
POL(false) = 0
POL(filterhigh(x₁, x₂)) = x₂
POL(filterlow(x₁, x₂)) = x₂
POL(ge(x₁, x₂)) = 0
POL(half(x₁)) = 0
POL(if1(x₁, x₂, x₃, x₄)) = 1 + x₄
POL(if2(x₁, x₂, x₃, x₄)) = 1 + x₄
POL(nil) = 0
POL(s(x₁)) = 0
POL(true) = 0

At least one of these decreasing rules is always used after the deleted DP:
if2(true, n821, x1051, xs611) → filterhigh(n821, xs611)

The following formula is valid:
x0':sort[a0],x1':sort[a0],x2':sort[a5].if2'(ge(x0' , x0' ), x0' , x0' , cons(x1' , x2' ))=true

The transformed set:
if2'(true, n82, x105, xs61) → true
filterhigh'(n91, cons(x116, xs68)) → if2'(ge(x116, n91), n91, x116, xs68)
if2'(false, n100, x127, xs75) → filterhigh'(n100, xs75)
filterhigh'(n109, nil) → false
ge(x', 0) → true
ge(s(x9), s(y'')) → ge(x9, y'')
if1(true, n14, x20, xs10) → filterlow(n14, xs10)
filterlow(n23, cons(x31, xs17)) → if1(ge(n23, x31), n23, x31, xs17)
if1(false, n32, x42, xs24) → cons(x42, filterlow(n32, xs24))
filterlow(n41, nil) → nil
ge(0, s(x63)) → false
half(0) → 0
half(s(0)) → 0
half(s(s(x94))) → s(half(x94))
if2(true, n82, x105, xs61) → filterhigh(n82, xs61)
filterhigh(n91, cons(x116, xs68)) → if2(ge(x116, n91), n91, x116, xs68)
if2(false, n100, x127, xs75) → cons(x127, filterhigh(n100, xs75))
filterhigh(n109, nil) → nil
equal_bool(true, false) → false
equal_bool(false, true) → false
equal_bool(true, true) → true
equal_bool(false, false) → true
and(true, x) → x
and(false, x) → false
or(true, x) → true
or(false, x) → x
not(false) → true
not(true) → false
isa_true(true) → true
isa_true(false) → false
isa_false(true) → false
isa_false(false) → true
equal_sort[a0](0, 0) → true
equal_sort[a0](0, s(x0)) → false
equal_sort[a0](s(x0), 0) → false
equal_sort[a0](s(x0), s(x1)) → equal_sort[a0](x0, x1)
equal_sort[a5](nil, nil) → true
equal_sort[a5](nil, cons(x0, x1)) → false
equal_sort[a5](cons(x0, x1), nil) → false
equal_sort[a5](cons(x0, x1), cons(x2, x3)) → and(equal_sort[a5](x0, x2), equal_sort[a5](x1, x3))
equal_sort[a65](witness_sort[a65], witness_sort[a65]) → true

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Rewriting

                          ↳ QDP

                            ↳ Rewriting

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Rewriting

                                                      ↳ QDP

                                                        ↳ Rewriting

                                                          ↳ QDP

                                                            ↳ Rewriting

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ Rewriting

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Rewriting

                                                                                          ↳ QDP

                                                                                            ↳ Rewriting

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

                                                                                                      ↳ QDP

                                                                                                        ↳ Rewriting

                                                                                                          ↳ QDP

                                                                                                            ↳ QDPOrderProof

                                                                                                              ↳ QDP

                                                                                                                ↳ QDPOrderProof

                                                                                                                  ↳ QDP

                                                                                                                    ↳ UsableRulesProof

                                                                                                                      ↳ QDP

                                                                                                                        ↳ QReductionProof

                                                                                                                          ↳ QDP

                                                                                                                            ↳ Induction-Processor

                                                                                                                              ↳ AND

                                                                                                                                ↳ QDP

                                                                                                                                  ↳ Induction-Processor

                                                                                                                                    ↳ AND

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ UsableRulesProof

                                                                                                                                      ↳ QTRS

                                                                                                                                ↳ QTRS

Q DP problem:
The TRS P consists of the following rules:

QS(x0, cons(x1, nil)) → QS(half(x0), if1(ge(x1, x1), x1, x1, nil))
QS(0, cons(x0, cons(x1, x2))) → QS(0, if1(ge(x0, x0), x0, x0, cons(x1, x2)))

The TRS R consists of the following rules:

ge(x, 0) → true
ge(s(x), s(y)) → ge(x, y)
if1(true, n, x, xs) → filterlow(n, xs)
filterlow(n, cons(x, xs)) → if1(ge(n, x), n, x, xs)
if1(false, n, x, xs) → cons(x, filterlow(n, xs))
filterlow(n, nil) → nil
ge(0, s(x)) → false
half(0) → 0
half(s(0)) → 0
half(s(s(x))) → s(half(x))
if2(true, n, x, xs) → filterhigh(n, xs)
filterhigh(n, cons(x, xs)) → if2(ge(x, n), n, x, xs)
if2(false, n, x, xs) → cons(x, filterhigh(n, xs))
filterhigh(n, nil) → nil

The set Q consists of the following terms:

filterlow(x0, nil)
filterlow(x0, cons(x1, x2))
if1(true, x0, x1, x2)
if1(false, x0, x1, x2)
filterhigh(x0, nil)
filterhigh(x0, cons(x1, x2))
if2(true, x0, x1, x2)
if2(false, x0, x1, x2)
ge(x0, 0)
ge(0, s(x0))
ge(s(x0), s(x1))
half(0)
half(s(0))
half(s(s(x0)))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Rewriting

                          ↳ QDP

                            ↳ Rewriting

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Rewriting

                                                      ↳ QDP

                                                        ↳ Rewriting

                                                          ↳ QDP

                                                            ↳ Rewriting

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ Rewriting

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Rewriting

                                                                                          ↳ QDP

                                                                                            ↳ Rewriting

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

                                                                                                      ↳ QDP

                                                                                                        ↳ Rewriting

                                                                                                          ↳ QDP

                                                                                                            ↳ QDPOrderProof

                                                                                                              ↳ QDP

                                                                                                                ↳ QDPOrderProof

                                                                                                                  ↳ QDP

                                                                                                                    ↳ UsableRulesProof

                                                                                                                      ↳ QDP

                                                                                                                        ↳ QReductionProof

                                                                                                                          ↳ QDP

                                                                                                                            ↳ Induction-Processor

                                                                                                                              ↳ AND

                                                                                                                                ↳ QDP

                                                                                                                                  ↳ Induction-Processor

                                                                                                                                    ↳ AND

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ UsableRulesProof

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ QReductionProof

                                                                                                                                      ↳ QTRS

                                                                                                                                ↳ QTRS

Q DP problem:
The TRS P consists of the following rules:

QS(x0, cons(x1, nil)) → QS(half(x0), if1(ge(x1, x1), x1, x1, nil))
QS(0, cons(x0, cons(x1, x2))) → QS(0, if1(ge(x0, x0), x0, x0, cons(x1, x2)))

The TRS R consists of the following rules:

ge(x, 0) → true
ge(s(x), s(y)) → ge(x, y)
if1(true, n, x, xs) → filterlow(n, xs)
filterlow(n, cons(x, xs)) → if1(ge(n, x), n, x, xs)
if1(false, n, x, xs) → cons(x, filterlow(n, xs))
filterlow(n, nil) → nil
ge(0, s(x)) → false
half(0) → 0
half(s(0)) → 0
half(s(s(x))) → s(half(x))

The set Q consists of the following terms:

filterlow(x0, nil)
filterlow(x0, cons(x1, x2))
if1(true, x0, x1, x2)
if1(false, x0, x1, x2)
filterhigh(x0, nil)
filterhigh(x0, cons(x1, x2))
if2(true, x0, x1, x2)
if2(false, x0, x1, x2)
ge(x0, 0)
ge(0, s(x0))
ge(s(x0), s(x1))
half(0)
half(s(0))
half(s(s(x0)))

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN].

filterhigh(x0, nil)
filterhigh(x0, cons(x1, x2))
if2(true, x0, x1, x2)
if2(false, x0, x1, x2)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Rewriting

                          ↳ QDP

                            ↳ Rewriting

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Rewriting

                                                      ↳ QDP

                                                        ↳ Rewriting

                                                          ↳ QDP

                                                            ↳ Rewriting

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ Rewriting

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Rewriting

                                                                                          ↳ QDP

                                                                                            ↳ Rewriting

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

                                                                                                      ↳ QDP

                                                                                                        ↳ Rewriting

                                                                                                          ↳ QDP

                                                                                                            ↳ QDPOrderProof

                                                                                                              ↳ QDP

                                                                                                                ↳ QDPOrderProof

                                                                                                                  ↳ QDP

                                                                                                                    ↳ UsableRulesProof

                                                                                                                      ↳ QDP

                                                                                                                        ↳ QReductionProof

                                                                                                                          ↳ QDP

                                                                                                                            ↳ Induction-Processor

                                                                                                                              ↳ AND

                                                                                                                                ↳ QDP

                                                                                                                                  ↳ Induction-Processor

                                                                                                                                    ↳ AND

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ UsableRulesProof

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ QReductionProof

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ Induction-Processor

                                                                                                                                      ↳ QTRS

                                                                                                                                ↳ QTRS

Q DP problem:
The TRS P consists of the following rules:

QS(x0, cons(x1, nil)) → QS(half(x0), if1(ge(x1, x1), x1, x1, nil))
QS(0, cons(x0, cons(x1, x2))) → QS(0, if1(ge(x0, x0), x0, x0, cons(x1, x2)))

The TRS R consists of the following rules:

ge(x, 0) → true
ge(s(x), s(y)) → ge(x, y)
if1(true, n, x, xs) → filterlow(n, xs)
filterlow(n, cons(x, xs)) → if1(ge(n, x), n, x, xs)
if1(false, n, x, xs) → cons(x, filterlow(n, xs))
filterlow(n, nil) → nil
ge(0, s(x)) → false
half(0) → 0
half(s(0)) → 0
half(s(s(x))) → s(half(x))

The set Q consists of the following terms:

filterlow(x0, nil)
filterlow(x0, cons(x1, x2))
if1(true, x0, x1, x2)
if1(false, x0, x1, x2)
ge(x0, 0)
ge(0, s(x0))
ge(s(x0), s(x1))
half(0)
half(s(0))
half(s(s(x0)))

We have to consider all minimal (P,Q,R)-chains.

This DP could be deleted by the Induction-Processor:
QS(x0', cons(x1', nil)) → QS(half(x0'), if1(ge(x1', x1'), x1', x1', nil))

This order was computed:
Polynomial interpretation [POLO]:

POL(0) = 1
POL(QS(x₁, x₂)) = x₂
POL(cons(x₁, x₂)) = 1 + x₂
POL(false) = 1
POL(filterlow(x₁, x₂)) = x₂
POL(ge(x₁, x₂)) = 1
POL(half(x₁)) = x₁
POL(if1(x₁, x₂, x₃, x₄)) = x₁ + x₄
POL(nil) = 1
POL(s(x₁)) = 1
POL(true) = 0

At least one of these decreasing rules is always used after the deleted DP:
ge(x'', 0) → true

The following formula is valid:
x1':sort[a0].(if1'(ge(x1' , x1' ), x1' , x1' , nil)=true∨ge'(x1' , x1' )=true)

The transformed set:
ge'(x', 0) → true
ge'(s(x6), s(y'')) → ge'(x6, y'')
if1'(true, n6, x14, xs4) → filterlow'(n6, xs4)
filterlow'(n11, cons(x22, xs8)) → or(if1'(ge(n11, x22), n11, x22, xs8), ge'(n11, x22))
if1'(false, n16, x30, xs12) → filterlow'(n16, xs12)
filterlow'(n21, nil) → false
ge'(0, s(x45)) → false
ge(x', 0) → true
ge(s(x6), s(y'')) → ge(x6, y'')
if1(true, n6, x14, xs4) → filterlow(n6, xs4)
filterlow(n11, cons(x22, xs8)) → if1(ge(n11, x22), n11, x22, xs8)
if1(false, n16, x30, xs12) → cons(x30, filterlow(n16, xs12))
filterlow(n21, nil) → nil
ge(0, s(x45)) → false
half(0) → 0
half(s(0)) → 0
half(s(s(x67))) → s(half(x67))
equal_bool(true, false) → false
equal_bool(false, true) → false
equal_bool(true, true) → true
equal_bool(false, false) → true
and(true, x) → x
and(false, x) → false
or(true, x) → true
or(false, x) → x
not(false) → true
not(true) → false
isa_true(true) → true
isa_true(false) → false
isa_false(true) → false
isa_false(false) → true
equal_sort[a0](0, 0) → true
equal_sort[a0](0, s(x0)) → false
equal_sort[a0](s(x0), 0) → false
equal_sort[a0](s(x0), s(x1)) → equal_sort[a0](x0, x1)
equal_sort[a5](nil, nil) → true
equal_sort[a5](nil, cons(x0, x1)) → false
equal_sort[a5](cons(x0, x1), nil) → false
equal_sort[a5](cons(x0, x1), cons(x2, x3)) → and(equal_sort[a5](x0, x2), equal_sort[a5](x1, x3))
equal_sort[a44](witness_sort[a44], witness_sort[a44]) → true

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Rewriting

                          ↳ QDP

                            ↳ Rewriting

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Rewriting

                                                      ↳ QDP

                                                        ↳ Rewriting

                                                          ↳ QDP

                                                            ↳ Rewriting

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ Rewriting

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Rewriting

                                                                                          ↳ QDP

                                                                                            ↳ Rewriting

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

                                                                                                      ↳ QDP

                                                                                                        ↳ Rewriting

                                                                                                          ↳ QDP

                                                                                                            ↳ QDPOrderProof

                                                                                                              ↳ QDP

                                                                                                                ↳ QDPOrderProof

                                                                                                                  ↳ QDP

                                                                                                                    ↳ UsableRulesProof

                                                                                                                      ↳ QDP

                                                                                                                        ↳ QReductionProof

                                                                                                                          ↳ QDP

                                                                                                                            ↳ Induction-Processor

                                                                                                                              ↳ AND

                                                                                                                                ↳ QDP

                                                                                                                                  ↳ Induction-Processor

                                                                                                                                    ↳ AND

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ UsableRulesProof

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ QReductionProof

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ Induction-Processor

                                                                                                                                                  ↳ AND

                                                                                                                                                    ↳ QDP

                                                                                                                                                      ↳ UsableRulesProof

                                                                                                                                                    ↳ QTRS

                                                                                                                                      ↳ QTRS

                                                                                                                                ↳ QTRS

Q DP problem:
The TRS P consists of the following rules:

QS(0, cons(x0, cons(x1, x2))) → QS(0, if1(ge(x0, x0), x0, x0, cons(x1, x2)))

The TRS R consists of the following rules:

ge(x, 0) → true
ge(s(x), s(y)) → ge(x, y)
if1(true, n, x, xs) → filterlow(n, xs)
filterlow(n, cons(x, xs)) → if1(ge(n, x), n, x, xs)
if1(false, n, x, xs) → cons(x, filterlow(n, xs))
filterlow(n, nil) → nil
ge(0, s(x)) → false
half(0) → 0
half(s(0)) → 0
half(s(s(x))) → s(half(x))

The set Q consists of the following terms:

filterlow(x0, nil)
filterlow(x0, cons(x1, x2))
if1(true, x0, x1, x2)
if1(false, x0, x1, x2)
ge(x0, 0)
ge(0, s(x0))
ge(s(x0), s(x1))
half(0)
half(s(0))
half(s(s(x0)))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Rewriting

                          ↳ QDP

                            ↳ Rewriting

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Rewriting

                                                      ↳ QDP

                                                        ↳ Rewriting

                                                          ↳ QDP

                                                            ↳ Rewriting

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ Rewriting

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Rewriting

                                                                                          ↳ QDP

                                                                                            ↳ Rewriting

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

                                                                                                      ↳ QDP

                                                                                                        ↳ Rewriting

                                                                                                          ↳ QDP

                                                                                                            ↳ QDPOrderProof

                                                                                                              ↳ QDP

                                                                                                                ↳ QDPOrderProof

                                                                                                                  ↳ QDP

                                                                                                                    ↳ UsableRulesProof

                                                                                                                      ↳ QDP

                                                                                                                        ↳ QReductionProof

                                                                                                                          ↳ QDP

                                                                                                                            ↳ Induction-Processor

                                                                                                                              ↳ AND

                                                                                                                                ↳ QDP

                                                                                                                                  ↳ Induction-Processor

                                                                                                                                    ↳ AND

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ UsableRulesProof

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ QReductionProof

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ Induction-Processor

                                                                                                                                                  ↳ AND

                                                                                                                                                    ↳ QDP

                                                                                                                                                      ↳ UsableRulesProof

                                                                                                                                                        ↳ QDP

                                                                                                                                                          ↳ QReductionProof

                                                                                                                                                    ↳ QTRS

                                                                                                                                      ↳ QTRS

                                                                                                                                ↳ QTRS

Q DP problem:
The TRS P consists of the following rules:

QS(0, cons(x0, cons(x1, x2))) → QS(0, if1(ge(x0, x0), x0, x0, cons(x1, x2)))

The TRS R consists of the following rules:

ge(x, 0) → true
ge(s(x), s(y)) → ge(x, y)
if1(true, n, x, xs) → filterlow(n, xs)
filterlow(n, cons(x, xs)) → if1(ge(n, x), n, x, xs)
if1(false, n, x, xs) → cons(x, filterlow(n, xs))
filterlow(n, nil) → nil
ge(0, s(x)) → false

The set Q consists of the following terms:

filterlow(x0, nil)
filterlow(x0, cons(x1, x2))
if1(true, x0, x1, x2)
if1(false, x0, x1, x2)
ge(x0, 0)
ge(0, s(x0))
ge(s(x0), s(x1))
half(0)
half(s(0))
half(s(s(x0)))

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN].

half(0)
half(s(0))
half(s(s(x0)))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Rewriting

                          ↳ QDP

                            ↳ Rewriting

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Rewriting

                                                      ↳ QDP

                                                        ↳ Rewriting

                                                          ↳ QDP

                                                            ↳ Rewriting

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ Rewriting

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Rewriting

                                                                                          ↳ QDP

                                                                                            ↳ Rewriting

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

                                                                                                      ↳ QDP

                                                                                                        ↳ Rewriting

                                                                                                          ↳ QDP

                                                                                                            ↳ QDPOrderProof

                                                                                                              ↳ QDP

                                                                                                                ↳ QDPOrderProof

                                                                                                                  ↳ QDP

                                                                                                                    ↳ UsableRulesProof

                                                                                                                      ↳ QDP

                                                                                                                        ↳ QReductionProof

                                                                                                                          ↳ QDP

                                                                                                                            ↳ Induction-Processor

                                                                                                                              ↳ AND

                                                                                                                                ↳ QDP

                                                                                                                                  ↳ Induction-Processor

                                                                                                                                    ↳ AND

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ UsableRulesProof

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ QReductionProof

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ Induction-Processor

                                                                                                                                                  ↳ AND

                                                                                                                                                    ↳ QDP

                                                                                                                                                      ↳ UsableRulesProof

                                                                                                                                                        ↳ QDP

                                                                                                                                                          ↳ QReductionProof

                                                                                                                                                            ↳ QDP

                                                                                                                                                              ↳ Induction-Processor

                                                                                                                                                    ↳ QTRS

                                                                                                                                      ↳ QTRS

                                                                                                                                ↳ QTRS

Q DP problem:
The TRS P consists of the following rules:

QS(0, cons(x0, cons(x1, x2))) → QS(0, if1(ge(x0, x0), x0, x0, cons(x1, x2)))

The TRS R consists of the following rules:

ge(x, 0) → true
ge(s(x), s(y)) → ge(x, y)
if1(true, n, x, xs) → filterlow(n, xs)
filterlow(n, cons(x, xs)) → if1(ge(n, x), n, x, xs)
if1(false, n, x, xs) → cons(x, filterlow(n, xs))
filterlow(n, nil) → nil
ge(0, s(x)) → false

The set Q consists of the following terms:

filterlow(x0, nil)
filterlow(x0, cons(x1, x2))
if1(true, x0, x1, x2)
if1(false, x0, x1, x2)
ge(x0, 0)
ge(0, s(x0))
ge(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.

This DP could be deleted by the Induction-Processor:
QS(0, cons(x0', cons(x1', x2'))) → QS(0, if1(ge(x0', x0'), x0', x0', cons(x1', x2')))

This order was computed:
Polynomial interpretation [POLO]:

POL(0) = 1
POL(QS(x₁, x₂)) = x₂
POL(cons(x₁, x₂)) = 1 + x₂
POL(false) = 1
POL(filterlow(x₁, x₂)) = x₂
POL(ge(x₁, x₂)) = 1 + x₁
POL(if1(x₁, x₂, x₃, x₄)) = 1 + x₄
POL(nil) = 0
POL(s(x₁)) = x₁
POL(true) = 0

At least one of these decreasing rules is always used after the deleted DP:
if1(true, n60, x120, xs40) → filterlow(n60, xs40)

The following formula is valid:
x0':sort[a0],x1':sort[a0],x2':sort[a5].if1'(ge(x0' , x0' ), x0' , x0' , cons(x1' , x2' ))=true

The transformed set:
if1'(true, n6, x12, xs4) → true
filterlow'(n11, cons(x19, xs8)) → if1'(ge(n11, x19), n11, x19, xs8)
if1'(false, n16, x26, xs12) → filterlow'(n16, xs12)
filterlow'(n21, nil) → false
ge(x', 0) → true
ge(s(x5), s(y'')) → ge(x5, y'')
if1(true, n6, x12, xs4) → filterlow(n6, xs4)
filterlow(n11, cons(x19, xs8)) → if1(ge(n11, x19), n11, x19, xs8)
if1(false, n16, x26, xs12) → cons(x26, filterlow(n16, xs12))
filterlow(n21, nil) → nil
ge(0, s(x39)) → false
equal_bool(true, false) → false
equal_bool(false, true) → false
equal_bool(true, true) → true
equal_bool(false, false) → true
and(true, x) → x
and(false, x) → false
or(true, x) → true
or(false, x) → x
not(false) → true
not(true) → false
isa_true(true) → true
isa_true(false) → false
isa_false(true) → false
isa_false(false) → true
equal_sort[a0](0, 0) → true
equal_sort[a0](0, s(x0)) → false
equal_sort[a0](s(x0), 0) → false
equal_sort[a0](s(x0), s(x1)) → equal_sort[a0](x0, x1)
equal_sort[a5](nil, nil) → true
equal_sort[a5](nil, cons(x0, x1)) → false
equal_sort[a5](cons(x0, x1), nil) → false
equal_sort[a5](cons(x0, x1), cons(x2, x3)) → and(equal_sort[a5](x0, x2), equal_sort[a5](x1, x3))
equal_sort[a39](witness_sort[a39], witness_sort[a39]) → true

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Rewriting

                          ↳ QDP

                            ↳ Rewriting

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Rewriting

                                                      ↳ QDP

                                                        ↳ Rewriting

                                                          ↳ QDP

                                                            ↳ Rewriting

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ Rewriting

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Rewriting

                                                                                          ↳ QDP

                                                                                            ↳ Rewriting

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

                                                                                                      ↳ QDP

                                                                                                        ↳ Rewriting

                                                                                                          ↳ QDP

                                                                                                            ↳ QDPOrderProof

                                                                                                              ↳ QDP

                                                                                                                ↳ QDPOrderProof

                                                                                                                  ↳ QDP

                                                                                                                    ↳ UsableRulesProof

                                                                                                                      ↳ QDP

                                                                                                                        ↳ QReductionProof

                                                                                                                          ↳ QDP

                                                                                                                            ↳ Induction-Processor

                                                                                                                              ↳ AND

                                                                                                                                ↳ QDP

                                                                                                                                  ↳ Induction-Processor

                                                                                                                                    ↳ AND

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ UsableRulesProof

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ QReductionProof

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ Induction-Processor

                                                                                                                                                  ↳ AND

                                                                                                                                                    ↳ QDP

                                                                                                                                                      ↳ UsableRulesProof

                                                                                                                                                        ↳ QDP

                                                                                                                                                          ↳ QReductionProof

                                                                                                                                                            ↳ QDP

                                                                                                                                                              ↳ Induction-Processor

                                                                                                                                                                ↳ AND

                                                                                                                                                                  ↳ QDP

                                                                                                                                                                    ↳ PisEmptyProof

                                                                                                                                                                  ↳ QTRS

                                                                                                                                                    ↳ QTRS

                                                                                                                                      ↳ QTRS

                                                                                                                                ↳ QTRS

Q DP problem:
P is empty.
The TRS R consists of the following rules:

ge(x, 0) → true
ge(s(x), s(y)) → ge(x, y)
if1(true, n, x, xs) → filterlow(n, xs)
filterlow(n, cons(x, xs)) → if1(ge(n, x), n, x, xs)
if1(false, n, x, xs) → cons(x, filterlow(n, xs))
filterlow(n, nil) → nil
ge(0, s(x)) → false

The set Q consists of the following terms:

filterlow(x0, nil)
filterlow(x0, cons(x1, x2))
if1(true, x0, x1, x2)
if1(false, x0, x1, x2)
ge(x0, 0)
ge(0, s(x0))
ge(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Rewriting

                          ↳ QDP

                            ↳ Rewriting

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Rewriting

                                                      ↳ QDP

                                                        ↳ Rewriting

                                                          ↳ QDP

                                                            ↳ Rewriting

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ Rewriting

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Rewriting

                                                                                          ↳ QDP

                                                                                            ↳ Rewriting

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

                                                                                                      ↳ QDP

                                                                                                        ↳ Rewriting

                                                                                                          ↳ QDP

                                                                                                            ↳ QDPOrderProof

                                                                                                              ↳ QDP

                                                                                                                ↳ QDPOrderProof

                                                                                                                  ↳ QDP

                                                                                                                    ↳ UsableRulesProof

                                                                                                                      ↳ QDP

                                                                                                                        ↳ QReductionProof

                                                                                                                          ↳ QDP

                                                                                                                            ↳ Induction-Processor

                                                                                                                              ↳ AND

                                                                                                                                ↳ QDP

                                                                                                                                  ↳ Induction-Processor

                                                                                                                                    ↳ AND

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ UsableRulesProof

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ QReductionProof

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ Induction-Processor

                                                                                                                                                  ↳ AND

                                                                                                                                                    ↳ QDP

                                                                                                                                                      ↳ UsableRulesProof

                                                                                                                                                        ↳ QDP

                                                                                                                                                          ↳ QReductionProof

                                                                                                                                                            ↳ QDP

                                                                                                                                                              ↳ Induction-Processor

                                                                                                                                                                ↳ AND

                                                                                                                                                                  ↳ QDP

                                                                                                                                                                  ↳ QTRS

                                                                                                                                                                    ↳ QTRSRRRProof

                                                                                                                                                    ↳ QTRS

                                                                                                                                      ↳ QTRS

                                                                                                                                ↳ QTRS

Q restricted rewrite system:
The TRS R consists of the following rules:

if1'(true, n6, x12, xs4) → true
filterlow'(n11, cons(x19, xs8)) → if1'(ge(n11, x19), n11, x19, xs8)
if1'(false, n16, x26, xs12) → filterlow'(n16, xs12)
filterlow'(n21, nil) → false
ge(x', 0) → true
ge(s(x5), s(y'')) → ge(x5, y'')
if1(true, n6, x12, xs4) → filterlow(n6, xs4)
filterlow(n11, cons(x19, xs8)) → if1(ge(n11, x19), n11, x19, xs8)
if1(false, n16, x26, xs12) → cons(x26, filterlow(n16, xs12))
filterlow(n21, nil) → nil
ge(0, s(x39)) → false
equal_bool(true, false) → false
equal_bool(false, true) → false
equal_bool(true, true) → true
equal_bool(false, false) → true
and(true, x) → x
and(false, x) → false
or(true, x) → true
or(false, x) → x
not(false) → true
not(true) → false
isa_true(true) → true
isa_true(false) → false
isa_false(true) → false
isa_false(false) → true
equal_sort[a0](0, 0) → true
equal_sort[a0](0, s(x0)) → false
equal_sort[a0](s(x0), 0) → false
equal_sort[a0](s(x0), s(x1)) → equal_sort[a0](x0, x1)
equal_sort[a5](nil, nil) → true
equal_sort[a5](nil, cons(x0, x1)) → false
equal_sort[a5](cons(x0, x1), nil) → false
equal_sort[a5](cons(x0, x1), cons(x2, x3)) → and(equal_sort[a5](x0, x2), equal_sort[a5](x1, x3))
equal_sort[a39](witness_sort[a39], witness_sort[a39]) → true

Q is empty.

The following Q TRS is given: Q restricted rewrite system:
The TRS R consists of the following rules:

if1'(true, n6, x12, xs4) → true
filterlow'(n11, cons(x19, xs8)) → if1'(ge(n11, x19), n11, x19, xs8)
if1'(false, n16, x26, xs12) → filterlow'(n16, xs12)
filterlow'(n21, nil) → false
ge(x', 0) → true
ge(s(x5), s(y'')) → ge(x5, y'')
if1(true, n6, x12, xs4) → filterlow(n6, xs4)
filterlow(n11, cons(x19, xs8)) → if1(ge(n11, x19), n11, x19, xs8)
if1(false, n16, x26, xs12) → cons(x26, filterlow(n16, xs12))
filterlow(n21, nil) → nil
ge(0, s(x39)) → false
equal_bool(true, false) → false
equal_bool(false, true) → false
equal_bool(true, true) → true
equal_bool(false, false) → true
and(true, x) → x
and(false, x) → false
or(true, x) → true
or(false, x) → x
not(false) → true
not(true) → false
isa_true(true) → true
isa_true(false) → false
isa_false(true) → false
isa_false(false) → true
equal_sort[a0](0, 0) → true
equal_sort[a0](0, s(x0)) → false
equal_sort[a0](s(x0), 0) → false
equal_sort[a0](s(x0), s(x1)) → equal_sort[a0](x0, x1)
equal_sort[a5](nil, nil) → true
equal_sort[a5](nil, cons(x0, x1)) → false
equal_sort[a5](cons(x0, x1), nil) → false
equal_sort[a5](cons(x0, x1), cons(x2, x3)) → and(equal_sort[a5](x0, x2), equal_sort[a5](x1, x3))
equal_sort[a39](witness_sort[a39], witness_sort[a39]) → true

Q is empty.
Used ordering:
Recursive path order with status [RPO].
Quasi-Precedence:

[if1'₄, filterlow'₂] > [ge₂, if1₄, filterlow₂] > [true, false, nil] > cons₂
equal_bool₂ > [true, false, nil] > cons₂
not₁ > [true, false, nil] > cons₂
isa_false₁ > [true, false, nil] > cons₂
equal_sort[a0]₂ > [true, false, nil] > cons₂
equal_sort[a5]₂ > and₂ > [true, false, nil] > cons₂
equal_sort[a39]₂ > [true, false, nil] > cons₂

Status:

if1'₄: [2,4,3,1]
true: multiset
or₂: [2,1]
and₂: multiset
filterlow'₂: [1,2]
0: multiset
equal_bool₂: [2,1]
equal_sort[a0]₂: multiset
equal_sort[a39]₂: [2,1]
cons₂: multiset
equal_sort[a5]₂: multiset
not₁: multiset
witness_sort[a39]: multiset
isa_false₁: multiset
false: multiset
filterlow₂: [2,1]
s₁: multiset
ge₂: [2,1]
nil: multiset
if1₄: [4,2,3,1]
isa_true₁: [1]

With this ordering the following rules can be removed by the rule removal processor [LPAR04] because they are oriented strictly:

if1'(true, n6, x12, xs4) → true
filterlow'(n11, cons(x19, xs8)) → if1'(ge(n11, x19), n11, x19, xs8)
if1'(false, n16, x26, xs12) → filterlow'(n16, xs12)
filterlow'(n21, nil) → false
ge(x', 0) → true
ge(s(x5), s(y'')) → ge(x5, y'')
if1(true, n6, x12, xs4) → filterlow(n6, xs4)
filterlow(n11, cons(x19, xs8)) → if1(ge(n11, x19), n11, x19, xs8)
if1(false, n16, x26, xs12) → cons(x26, filterlow(n16, xs12))
filterlow(n21, nil) → nil
ge(0, s(x39)) → false
equal_bool(true, false) → false
equal_bool(false, true) → false
equal_bool(true, true) → true
equal_bool(false, false) → true
and(true, x) → x
and(false, x) → false
or(true, x) → true
or(false, x) → x
not(false) → true
not(true) → false
isa_true(true) → true
isa_true(false) → false
isa_false(true) → false
isa_false(false) → true
equal_sort[a0](0, 0) → true
equal_sort[a0](0, s(x0)) → false
equal_sort[a0](s(x0), 0) → false
equal_sort[a0](s(x0), s(x1)) → equal_sort[a0](x0, x1)
equal_sort[a5](nil, nil) → true
equal_sort[a5](nil, cons(x0, x1)) → false
equal_sort[a5](cons(x0, x1), nil) → false
equal_sort[a5](cons(x0, x1), cons(x2, x3)) → and(equal_sort[a5](x0, x2), equal_sort[a5](x1, x3))
equal_sort[a39](witness_sort[a39], witness_sort[a39]) → true

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Rewriting

                          ↳ QDP

                            ↳ Rewriting

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Rewriting

                                                      ↳ QDP

                                                        ↳ Rewriting

                                                          ↳ QDP

                                                            ↳ Rewriting

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ Rewriting

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Rewriting

                                                                                          ↳ QDP

                                                                                            ↳ Rewriting

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

                                                                                                      ↳ QDP

                                                                                                        ↳ Rewriting

                                                                                                          ↳ QDP

                                                                                                            ↳ QDPOrderProof

                                                                                                              ↳ QDP

                                                                                                                ↳ QDPOrderProof

                                                                                                                  ↳ QDP

                                                                                                                    ↳ UsableRulesProof

                                                                                                                      ↳ QDP

                                                                                                                        ↳ QReductionProof

                                                                                                                          ↳ QDP

                                                                                                                            ↳ Induction-Processor

                                                                                                                              ↳ AND

                                                                                                                                ↳ QDP

                                                                                                                                  ↳ Induction-Processor

                                                                                                                                    ↳ AND

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ UsableRulesProof

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ QReductionProof

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ Induction-Processor

                                                                                                                                                  ↳ AND

                                                                                                                                                    ↳ QDP

                                                                                                                                                      ↳ UsableRulesProof

                                                                                                                                                        ↳ QDP

                                                                                                                                                          ↳ QReductionProof

                                                                                                                                                            ↳ QDP

                                                                                                                                                              ↳ Induction-Processor

                                                                                                                                                                ↳ AND

                                                                                                                                                                  ↳ QDP

                                                                                                                                                                  ↳ QTRS

                                                                                                                                                                    ↳ QTRSRRRProof

                                                                                                                                                                      ↳ QTRS

                                                                                                                                                                        ↳ RisEmptyProof

                                                                                                                                                                        ↳ RisEmptyProof

                                                                                                                                                                        ↳ RisEmptyProof

                                                                                                                                                    ↳ QTRS

                                                                                                                                      ↳ QTRS

                                                                                                                                ↳ QTRS

Q restricted rewrite system:
R is empty.
Q is empty.

The TRS R is empty. Hence, termination is trivially proven.
The TRS R is empty. Hence, termination is trivially proven.
The TRS R is empty. Hence, termination is trivially proven.

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Rewriting

                          ↳ QDP

                            ↳ Rewriting

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Rewriting

                                                      ↳ QDP

                                                        ↳ Rewriting

                                                          ↳ QDP

                                                            ↳ Rewriting

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ Rewriting

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Rewriting

                                                                                          ↳ QDP

                                                                                            ↳ Rewriting

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

                                                                                                      ↳ QDP

                                                                                                        ↳ Rewriting

                                                                                                          ↳ QDP

                                                                                                            ↳ QDPOrderProof

                                                                                                              ↳ QDP

                                                                                                                ↳ QDPOrderProof

                                                                                                                  ↳ QDP

                                                                                                                    ↳ UsableRulesProof

                                                                                                                      ↳ QDP

                                                                                                                        ↳ QReductionProof

                                                                                                                          ↳ QDP

                                                                                                                            ↳ Induction-Processor

                                                                                                                              ↳ AND

                                                                                                                                ↳ QDP

                                                                                                                                  ↳ Induction-Processor

                                                                                                                                    ↳ AND

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ UsableRulesProof

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ QReductionProof

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ Induction-Processor

                                                                                                                                                  ↳ AND

                                                                                                                                                    ↳ QDP

                                                                                                                                                    ↳ QTRS

                                                                                                                                                      ↳ QTRSRRRProof

                                                                                                                                      ↳ QTRS

                                                                                                                                ↳ QTRS

Q restricted rewrite system:
The TRS R consists of the following rules:

ge'(x', 0) → true
ge'(s(x6), s(y'')) → ge'(x6, y'')
if1'(true, n6, x14, xs4) → filterlow'(n6, xs4)
filterlow'(n11, cons(x22, xs8)) → or(if1'(ge(n11, x22), n11, x22, xs8), ge'(n11, x22))
if1'(false, n16, x30, xs12) → filterlow'(n16, xs12)
filterlow'(n21, nil) → false
ge'(0, s(x45)) → false
ge(x', 0) → true
ge(s(x6), s(y'')) → ge(x6, y'')
if1(true, n6, x14, xs4) → filterlow(n6, xs4)
filterlow(n11, cons(x22, xs8)) → if1(ge(n11, x22), n11, x22, xs8)
if1(false, n16, x30, xs12) → cons(x30, filterlow(n16, xs12))
filterlow(n21, nil) → nil
ge(0, s(x45)) → false
half(0) → 0
half(s(0)) → 0
half(s(s(x67))) → s(half(x67))
equal_bool(true, false) → false
equal_bool(false, true) → false
equal_bool(true, true) → true
equal_bool(false, false) → true
and(true, x) → x
and(false, x) → false
or(true, x) → true
or(false, x) → x
not(false) → true
not(true) → false
isa_true(true) → true
isa_true(false) → false
isa_false(true) → false
isa_false(false) → true
equal_sort[a0](0, 0) → true
equal_sort[a0](0, s(x0)) → false
equal_sort[a0](s(x0), 0) → false
equal_sort[a0](s(x0), s(x1)) → equal_sort[a0](x0, x1)
equal_sort[a5](nil, nil) → true
equal_sort[a5](nil, cons(x0, x1)) → false
equal_sort[a5](cons(x0, x1), nil) → false
equal_sort[a5](cons(x0, x1), cons(x2, x3)) → and(equal_sort[a5](x0, x2), equal_sort[a5](x1, x3))
equal_sort[a44](witness_sort[a44], witness_sort[a44]) → true

Q is empty.

The following Q TRS is given: Q restricted rewrite system:
The TRS R consists of the following rules:

ge'(x', 0) → true
ge'(s(x6), s(y'')) → ge'(x6, y'')
if1'(true, n6, x14, xs4) → filterlow'(n6, xs4)
filterlow'(n11, cons(x22, xs8)) → or(if1'(ge(n11, x22), n11, x22, xs8), ge'(n11, x22))
if1'(false, n16, x30, xs12) → filterlow'(n16, xs12)
filterlow'(n21, nil) → false
ge'(0, s(x45)) → false
ge(x', 0) → true
ge(s(x6), s(y'')) → ge(x6, y'')
if1(true, n6, x14, xs4) → filterlow(n6, xs4)
filterlow(n11, cons(x22, xs8)) → if1(ge(n11, x22), n11, x22, xs8)
if1(false, n16, x30, xs12) → cons(x30, filterlow(n16, xs12))
filterlow(n21, nil) → nil
ge(0, s(x45)) → false
half(0) → 0
half(s(0)) → 0
half(s(s(x67))) → s(half(x67))
equal_bool(true, false) → false
equal_bool(false, true) → false
equal_bool(true, true) → true
equal_bool(false, false) → true
and(true, x) → x
and(false, x) → false
or(true, x) → true
or(false, x) → x
not(false) → true
not(true) → false
isa_true(true) → true
isa_true(false) → false
isa_false(true) → false
isa_false(false) → true
equal_sort[a0](0, 0) → true
equal_sort[a0](0, s(x0)) → false
equal_sort[a0](s(x0), 0) → false
equal_sort[a0](s(x0), s(x1)) → equal_sort[a0](x0, x1)
equal_sort[a5](nil, nil) → true
equal_sort[a5](nil, cons(x0, x1)) → false
equal_sort[a5](cons(x0, x1), nil) → false
equal_sort[a5](cons(x0, x1), cons(x2, x3)) → and(equal_sort[a5](x0, x2), equal_sort[a5](x1, x3))
equal_sort[a44](witness_sort[a44], witness_sort[a44]) → true

Q is empty.
Used ordering:
Combined order from the following AFS and order.
ge'(x1, x2) = ge'(x1, x2)
0 = 0
true = true
s(x1) = x1
if1'(x1, x2, x3, x4) = if1'(x1, x2, x3, x4)
filterlow'(x1, x2) = filterlow'(x1, x2)
cons(x1, x2) = cons(x1, x2)
or(x1, x2) = or(x1, x2)
ge(x1, x2) = ge(x1, x2)
false = false
nil = nil
if1(x1, x2, x3, x4) = if1(x1, x2, x3, x4)
filterlow(x1, x2) = filterlow(x1, x2)
half(x1) = half(x1)
equal_bool(x1, x2) = equal_bool(x1, x2)
and(x1, x2) = and(x1, x2)
not(x1) = not(x1)
isa_true(x1) = isa_true(x1)
isa_false(x1) = isa_false(x1)
equal_sort[a0](x1, x2) = equal_sort[a0](x1, x2)
equal_sort[a5](x1, x2) = equal_sort[a5](x1, x2)
equal_sort[a44](x1, x2) = equal_sort[a44](x1, x2)
witness_sort[a44] = witness_sort[a44]

Recursive path order with status [RPO].
Quasi-Precedence:

[ge'₂, if1'₄, filterlow'₂, ge₂, if1₄, filterlow₂] > [cons₂, or₂, false, isa_false₁] > [true, equal_sort[a5]₂] > and₂
[ge'₂, if1'₄, filterlow'₂, ge₂, if1₄, filterlow₂] > nil
half₁ > 0
not₁ > [cons₂, or₂, false, isa_false₁] > [true, equal_sort[a5]₂] > and₂
equal_sort[a0]₂ > [cons₂, or₂, false, isa_false₁] > [true, equal_sort[a5]₂] > and₂
witness_sort[a44] > [true, equal_sort[a5]₂] > and₂

Status:

ge'₂: [1,2]
true: multiset
if1'₄: [2,4,1,3]
or₂: [2,1]
and₂: [2,1]
filterlow'₂: [1,2]
0: multiset
equal_sort[a44]₂: multiset
witness_sort[a44]: multiset
equal_bool₂: multiset
equal_sort[a0]₂: [1,2]
cons₂: multiset
equal_sort[a5]₂: [2,1]
half₁: [1]
not₁: [1]
isa_false₁: multiset
false: multiset
filterlow₂: [1,2]
ge₂: [1,2]
nil: multiset
if1₄: [2,4,3,1]
isa_true₁: [1]

With this ordering the following rules can be removed by the rule removal processor [LPAR04] because they are oriented strictly:

ge'(x', 0) → true
if1'(true, n6, x14, xs4) → filterlow'(n6, xs4)
filterlow'(n11, cons(x22, xs8)) → or(if1'(ge(n11, x22), n11, x22, xs8), ge'(n11, x22))
if1'(false, n16, x30, xs12) → filterlow'(n16, xs12)
filterlow'(n21, nil) → false
ge'(0, s(x45)) → false
ge(x', 0) → true
if1(true, n6, x14, xs4) → filterlow(n6, xs4)
filterlow(n11, cons(x22, xs8)) → if1(ge(n11, x22), n11, x22, xs8)
if1(false, n16, x30, xs12) → cons(x30, filterlow(n16, xs12))
filterlow(n21, nil) → nil
ge(0, s(x45)) → false
half(0) → 0
half(s(0)) → 0
equal_bool(true, false) → false
equal_bool(false, true) → false
equal_bool(true, true) → true
equal_bool(false, false) → true
and(true, x) → x
and(false, x) → false
or(true, x) → true
or(false, x) → x
not(false) → true
not(true) → false
isa_true(true) → true
isa_true(false) → false
isa_false(true) → false
isa_false(false) → true
equal_sort[a0](0, 0) → true
equal_sort[a0](0, s(x0)) → false
equal_sort[a0](s(x0), 0) → false
equal_sort[a5](nil, nil) → true
equal_sort[a5](nil, cons(x0, x1)) → false
equal_sort[a5](cons(x0, x1), nil) → false
equal_sort[a5](cons(x0, x1), cons(x2, x3)) → and(equal_sort[a5](x0, x2), equal_sort[a5](x1, x3))
equal_sort[a44](witness_sort[a44], witness_sort[a44]) → true

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Rewriting

                          ↳ QDP

                            ↳ Rewriting

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Rewriting

                                                      ↳ QDP

                                                        ↳ Rewriting

                                                          ↳ QDP

                                                            ↳ Rewriting

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ Rewriting

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Rewriting

                                                                                          ↳ QDP

                                                                                            ↳ Rewriting

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

                                                                                                      ↳ QDP

                                                                                                        ↳ Rewriting

                                                                                                          ↳ QDP

                                                                                                            ↳ QDPOrderProof

                                                                                                              ↳ QDP

                                                                                                                ↳ QDPOrderProof

                                                                                                                  ↳ QDP

                                                                                                                    ↳ UsableRulesProof

                                                                                                                      ↳ QDP

                                                                                                                        ↳ QReductionProof

                                                                                                                          ↳ QDP

                                                                                                                            ↳ Induction-Processor

                                                                                                                              ↳ AND

                                                                                                                                ↳ QDP

                                                                                                                                  ↳ Induction-Processor

                                                                                                                                    ↳ AND

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ UsableRulesProof

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ QReductionProof

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ Induction-Processor

                                                                                                                                                  ↳ AND

                                                                                                                                                    ↳ QDP

                                                                                                                                                    ↳ QTRS

                                                                                                                                                      ↳ QTRSRRRProof

                                                                                                                                                        ↳ QTRS

                                                                                                                                                          ↳ QTRSRRRProof

                                                                                                                                      ↳ QTRS

                                                                                                                                ↳ QTRS

Q restricted rewrite system:
The TRS R consists of the following rules:

ge'(s(x6), s(y'')) → ge'(x6, y'')
ge(s(x6), s(y'')) → ge(x6, y'')
half(s(s(x67))) → s(half(x67))
equal_sort[a0](s(x0), s(x1)) → equal_sort[a0](x0, x1)

Q is empty.

The following Q TRS is given: Q restricted rewrite system:
The TRS R consists of the following rules:

ge'(s(x6), s(y'')) → ge'(x6, y'')
ge(s(x6), s(y'')) → ge(x6, y'')
half(s(s(x67))) → s(half(x67))
equal_sort[a0](s(x0), s(x1)) → equal_sort[a0](x0, x1)

Q is empty.
Used ordering:
Recursive path order with status [RPO].
Quasi-Precedence:

ge₂ > ge'₂
half₁ > [s₁, equal_sort[a0]₂] > ge'₂

Status:

ge'₂: [2,1]
half₁: [1]
s₁: multiset
ge₂: [1,2]
equal_sort[a0]₂: multiset

With this ordering the following rules can be removed by the rule removal processor [LPAR04] because they are oriented strictly:

ge'(s(x6), s(y'')) → ge'(x6, y'')
ge(s(x6), s(y'')) → ge(x6, y'')
half(s(s(x67))) → s(half(x67))
equal_sort[a0](s(x0), s(x1)) → equal_sort[a0](x0, x1)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Rewriting

                          ↳ QDP

                            ↳ Rewriting

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Rewriting

                                                      ↳ QDP

                                                        ↳ Rewriting

                                                          ↳ QDP

                                                            ↳ Rewriting

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ Rewriting

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Rewriting

                                                                                          ↳ QDP

                                                                                            ↳ Rewriting

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

                                                                                                      ↳ QDP

                                                                                                        ↳ Rewriting

                                                                                                          ↳ QDP

                                                                                                            ↳ QDPOrderProof

                                                                                                              ↳ QDP

                                                                                                                ↳ QDPOrderProof

                                                                                                                  ↳ QDP

                                                                                                                    ↳ UsableRulesProof

                                                                                                                      ↳ QDP

                                                                                                                        ↳ QReductionProof

                                                                                                                          ↳ QDP

                                                                                                                            ↳ Induction-Processor

                                                                                                                              ↳ AND

                                                                                                                                ↳ QDP

                                                                                                                                  ↳ Induction-Processor

                                                                                                                                    ↳ AND

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ UsableRulesProof

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ QReductionProof

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ Induction-Processor

                                                                                                                                                  ↳ AND

                                                                                                                                                    ↳ QDP

                                                                                                                                                    ↳ QTRS

                                                                                                                                                      ↳ QTRSRRRProof

                                                                                                                                                        ↳ QTRS

                                                                                                                                                          ↳ QTRSRRRProof

                                                                                                                                                            ↳ QTRS

                                                                                                                                                              ↳ RisEmptyProof

                                                                                                                                      ↳ QTRS

                                                                                                                                ↳ QTRS

Q restricted rewrite system:
R is empty.
Q is empty.

The TRS R is empty. Hence, termination is trivially proven.

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Rewriting

                          ↳ QDP

                            ↳ Rewriting

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Rewriting

                                                      ↳ QDP

                                                        ↳ Rewriting

                                                          ↳ QDP

                                                            ↳ Rewriting

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ Rewriting

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Rewriting

                                                                                          ↳ QDP

                                                                                            ↳ Rewriting

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

                                                                                                      ↳ QDP

                                                                                                        ↳ Rewriting

                                                                                                          ↳ QDP

                                                                                                            ↳ QDPOrderProof

                                                                                                              ↳ QDP

                                                                                                                ↳ QDPOrderProof

                                                                                                                  ↳ QDP

                                                                                                                    ↳ UsableRulesProof

                                                                                                                      ↳ QDP

                                                                                                                        ↳ QReductionProof

                                                                                                                          ↳ QDP

                                                                                                                            ↳ Induction-Processor

                                                                                                                              ↳ AND

                                                                                                                                ↳ QDP

                                                                                                                                  ↳ Induction-Processor

                                                                                                                                    ↳ AND

                                                                                                                                      ↳ QDP

                                                                                                                                      ↳ QTRS

                                                                                                                                        ↳ QTRSRRRProof

                                                                                                                                ↳ QTRS

Q restricted rewrite system:
The TRS R consists of the following rules:

if2'(true, n82, x105, xs61) → true
filterhigh'(n91, cons(x116, xs68)) → if2'(ge(x116, n91), n91, x116, xs68)
if2'(false, n100, x127, xs75) → filterhigh'(n100, xs75)
filterhigh'(n109, nil) → false
ge(x', 0) → true
ge(s(x9), s(y'')) → ge(x9, y'')
if1(true, n14, x20, xs10) → filterlow(n14, xs10)
filterlow(n23, cons(x31, xs17)) → if1(ge(n23, x31), n23, x31, xs17)
if1(false, n32, x42, xs24) → cons(x42, filterlow(n32, xs24))
filterlow(n41, nil) → nil
ge(0, s(x63)) → false
half(0) → 0
half(s(0)) → 0
half(s(s(x94))) → s(half(x94))
if2(true, n82, x105, xs61) → filterhigh(n82, xs61)
filterhigh(n91, cons(x116, xs68)) → if2(ge(x116, n91), n91, x116, xs68)
if2(false, n100, x127, xs75) → cons(x127, filterhigh(n100, xs75))
filterhigh(n109, nil) → nil
equal_bool(true, false) → false
equal_bool(false, true) → false
equal_bool(true, true) → true
equal_bool(false, false) → true
and(true, x) → x
and(false, x) → false
or(true, x) → true
or(false, x) → x
not(false) → true
not(true) → false
isa_true(true) → true
isa_true(false) → false
isa_false(true) → false
isa_false(false) → true
equal_sort[a0](0, 0) → true
equal_sort[a0](0, s(x0)) → false
equal_sort[a0](s(x0), 0) → false
equal_sort[a0](s(x0), s(x1)) → equal_sort[a0](x0, x1)
equal_sort[a5](nil, nil) → true
equal_sort[a5](nil, cons(x0, x1)) → false
equal_sort[a5](cons(x0, x1), nil) → false
equal_sort[a5](cons(x0, x1), cons(x2, x3)) → and(equal_sort[a5](x0, x2), equal_sort[a5](x1, x3))
equal_sort[a65](witness_sort[a65], witness_sort[a65]) → true

Q is empty.

The following Q TRS is given: Q restricted rewrite system:
The TRS R consists of the following rules:

if2'(true, n82, x105, xs61) → true
filterhigh'(n91, cons(x116, xs68)) → if2'(ge(x116, n91), n91, x116, xs68)
if2'(false, n100, x127, xs75) → filterhigh'(n100, xs75)
filterhigh'(n109, nil) → false
ge(x', 0) → true
ge(s(x9), s(y'')) → ge(x9, y'')
if1(true, n14, x20, xs10) → filterlow(n14, xs10)
filterlow(n23, cons(x31, xs17)) → if1(ge(n23, x31), n23, x31, xs17)
if1(false, n32, x42, xs24) → cons(x42, filterlow(n32, xs24))
filterlow(n41, nil) → nil
ge(0, s(x63)) → false
half(0) → 0
half(s(0)) → 0
half(s(s(x94))) → s(half(x94))
if2(true, n82, x105, xs61) → filterhigh(n82, xs61)
filterhigh(n91, cons(x116, xs68)) → if2(ge(x116, n91), n91, x116, xs68)
if2(false, n100, x127, xs75) → cons(x127, filterhigh(n100, xs75))
filterhigh(n109, nil) → nil
equal_bool(true, false) → false
equal_bool(false, true) → false
equal_bool(true, true) → true
equal_bool(false, false) → true
and(true, x) → x
and(false, x) → false
or(true, x) → true
or(false, x) → x
not(false) → true
not(true) → false
isa_true(true) → true
isa_true(false) → false
isa_false(true) → false
isa_false(false) → true
equal_sort[a0](0, 0) → true
equal_sort[a0](0, s(x0)) → false
equal_sort[a0](s(x0), 0) → false
equal_sort[a0](s(x0), s(x1)) → equal_sort[a0](x0, x1)
equal_sort[a5](nil, nil) → true
equal_sort[a5](nil, cons(x0, x1)) → false
equal_sort[a5](cons(x0, x1), nil) → false
equal_sort[a5](cons(x0, x1), cons(x2, x3)) → and(equal_sort[a5](x0, x2), equal_sort[a5](x1, x3))
equal_sort[a65](witness_sort[a65], witness_sort[a65]) → true

Q is empty.
Used ordering:
Combined order from the following AFS and order.
if2'(x1, x2, x3, x4) = if2'(x1, x2, x3, x4)
true = true
filterhigh'(x1, x2) = filterhigh'(x1, x2)
cons(x1, x2) = cons(x1, x2)
ge(x1, x2) = ge(x1, x2)
false = false
nil = nil
0 = 0
s(x1) = x1
if1(x1, x2, x3, x4) = if1(x1, x2, x3, x4)
filterlow(x1, x2) = filterlow(x1, x2)
half(x1) = half(x1)
if2(x1, x2, x3, x4) = if2(x1, x2, x3, x4)
filterhigh(x1, x2) = filterhigh(x1, x2)
equal_bool(x1, x2) = equal_bool(x1, x2)
and(x1, x2) = and(x1, x2)
or(x1, x2) = or(x1, x2)
not(x1) = not(x1)
isa_true(x1) = isa_true(x1)
isa_false(x1) = x1
equal_sort[a0](x1, x2) = equal_sort[a0](x1, x2)
equal_sort[a5](x1, x2) = equal_sort[a5](x1, x2)
equal_sort[a65](x1, x2) = equal_sort[a65](x1, x2)
witness_sort[a65] = witness_sort[a65]

Recursive path order with status [RPO].
Quasi-Precedence:

[if2'₄, filterhigh'₂] > [ge₂, if1₄, filterlow₂] > [true, cons₂, false, nil, 0, isa_true₁, equal_sort[a65]₂, witness_sort[a65]] > and₂
[if2₄, filterhigh₂] > [ge₂, if1₄, filterlow₂] > [true, cons₂, false, nil, 0, isa_true₁, equal_sort[a65]₂, witness_sort[a65]] > and₂
or₂ > [true, cons₂, false, nil, 0, isa_true₁, equal_sort[a65]₂, witness_sort[a65]] > and₂
equal_sort[a0]₂ > [true, cons₂, false, nil, 0, isa_true₁, equal_sort[a65]₂, witness_sort[a65]] > and₂
equal_sort[a5]₂ > [true, cons₂, false, nil, 0, isa_true₁, equal_sort[a65]₂, witness_sort[a65]] > and₂

Status:

if2₄: [4,2,1,3]
true: multiset
filterhigh'₂: [1,2]
filterhigh₂: [2,1]
or₂: multiset
and₂: multiset
if2'₄: [2,4,1,3]
0: multiset
equal_bool₂: multiset
equal_sort[a0]₂: [1,2]
cons₂: multiset
equal_sort[a5]₂: multiset
half₁: [1]
equal_sort[a65]₂: multiset
not₁: multiset
false: multiset
filterlow₂: [1,2]
witness_sort[a65]: multiset
ge₂: [1,2]
nil: multiset
if1₄: [2,4,1,3]
isa_true₁: multiset

With this ordering the following rules can be removed by the rule removal processor [LPAR04] because they are oriented strictly:

if2'(true, n82, x105, xs61) → true
filterhigh'(n91, cons(x116, xs68)) → if2'(ge(x116, n91), n91, x116, xs68)
if2'(false, n100, x127, xs75) → filterhigh'(n100, xs75)
filterhigh'(n109, nil) → false
ge(x', 0) → true
if1(true, n14, x20, xs10) → filterlow(n14, xs10)
filterlow(n23, cons(x31, xs17)) → if1(ge(n23, x31), n23, x31, xs17)
if1(false, n32, x42, xs24) → cons(x42, filterlow(n32, xs24))
filterlow(n41, nil) → nil
ge(0, s(x63)) → false
half(0) → 0
half(s(0)) → 0
if2(true, n82, x105, xs61) → filterhigh(n82, xs61)
filterhigh(n91, cons(x116, xs68)) → if2(ge(x116, n91), n91, x116, xs68)
if2(false, n100, x127, xs75) → cons(x127, filterhigh(n100, xs75))
filterhigh(n109, nil) → nil
equal_bool(true, false) → false
equal_bool(false, true) → false
equal_bool(true, true) → true
equal_bool(false, false) → true
and(true, x) → x
and(false, x) → false
or(true, x) → true
or(false, x) → x
not(false) → true
not(true) → false
isa_true(true) → true
isa_true(false) → false
equal_sort[a0](0, 0) → true
equal_sort[a0](0, s(x0)) → false
equal_sort[a0](s(x0), 0) → false
equal_sort[a5](nil, nil) → true
equal_sort[a5](nil, cons(x0, x1)) → false
equal_sort[a5](cons(x0, x1), nil) → false
equal_sort[a5](cons(x0, x1), cons(x2, x3)) → and(equal_sort[a5](x0, x2), equal_sort[a5](x1, x3))
equal_sort[a65](witness_sort[a65], witness_sort[a65]) → true

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Rewriting

                          ↳ QDP

                            ↳ Rewriting

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Rewriting

                                                      ↳ QDP

                                                        ↳ Rewriting

                                                          ↳ QDP

                                                            ↳ Rewriting

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ Rewriting

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Rewriting

                                                                                          ↳ QDP

                                                                                            ↳ Rewriting

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

                                                                                                      ↳ QDP

                                                                                                        ↳ Rewriting

                                                                                                          ↳ QDP

                                                                                                            ↳ QDPOrderProof

                                                                                                              ↳ QDP

                                                                                                                ↳ QDPOrderProof

                                                                                                                  ↳ QDP

                                                                                                                    ↳ UsableRulesProof

                                                                                                                      ↳ QDP

                                                                                                                        ↳ QReductionProof

                                                                                                                          ↳ QDP

                                                                                                                            ↳ Induction-Processor

                                                                                                                              ↳ AND

                                                                                                                                ↳ QDP

                                                                                                                                  ↳ Induction-Processor

                                                                                                                                    ↳ AND

                                                                                                                                      ↳ QDP

                                                                                                                                      ↳ QTRS

                                                                                                                                        ↳ QTRSRRRProof

                                                                                                                                          ↳ QTRS

                                                                                                                                            ↳ QTRSRRRProof

                                                                                                                                ↳ QTRS

Q restricted rewrite system:
The TRS R consists of the following rules:

ge(s(x9), s(y'')) → ge(x9, y'')
half(s(s(x94))) → s(half(x94))
isa_false(true) → false
isa_false(false) → true
equal_sort[a0](s(x0), s(x1)) → equal_sort[a0](x0, x1)

Q is empty.

The following Q TRS is given: Q restricted rewrite system:
The TRS R consists of the following rules:

ge(s(x9), s(y'')) → ge(x9, y'')
half(s(s(x94))) → s(half(x94))
isa_false(true) → false
isa_false(false) → true
equal_sort[a0](s(x0), s(x1)) → equal_sort[a0](x0, x1)

Q is empty.
Used ordering:
Polynomial interpretation [POLO]:

POL(equal_sort[a0](x₁, x₂)) = x₁ + x₂
POL(false) = 2
POL(ge(x₁, x₂)) = 2·x₁ + x₂
POL(half(x₁)) = 2 + 2·x₁
POL(isa_false(x₁)) = 2 + 2·x₁
POL(s(x₁)) = 1 + 2·x₁
POL(true) = 1

With this ordering the following rules can be removed by the rule removal processor [LPAR04] because they are oriented strictly:

ge(s(x9), s(y'')) → ge(x9, y'')
half(s(s(x94))) → s(half(x94))
isa_false(true) → false
isa_false(false) → true
equal_sort[a0](s(x0), s(x1)) → equal_sort[a0](x0, x1)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Rewriting

                          ↳ QDP

                            ↳ Rewriting

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Rewriting

                                                      ↳ QDP

                                                        ↳ Rewriting

                                                          ↳ QDP

                                                            ↳ Rewriting

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ Rewriting

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Rewriting

                                                                                          ↳ QDP

                                                                                            ↳ Rewriting

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

                                                                                                      ↳ QDP

                                                                                                        ↳ Rewriting

                                                                                                          ↳ QDP

                                                                                                            ↳ QDPOrderProof

                                                                                                              ↳ QDP

                                                                                                                ↳ QDPOrderProof

                                                                                                                  ↳ QDP

                                                                                                                    ↳ UsableRulesProof

                                                                                                                      ↳ QDP

                                                                                                                        ↳ QReductionProof

                                                                                                                          ↳ QDP

                                                                                                                            ↳ Induction-Processor

                                                                                                                              ↳ AND

                                                                                                                                ↳ QDP

                                                                                                                                  ↳ Induction-Processor

                                                                                                                                    ↳ AND

                                                                                                                                      ↳ QDP

                                                                                                                                      ↳ QTRS

                                                                                                                                        ↳ QTRSRRRProof

                                                                                                                                          ↳ QTRS

                                                                                                                                            ↳ QTRSRRRProof

                                                                                                                                              ↳ QTRS

                                                                                                                                                ↳ RisEmptyProof

                                                                                                                                                ↳ RisEmptyProof

                                                                                                                                                ↳ RisEmptyProof

                                                                                                                                ↳ QTRS

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Rewriting

                          ↳ QDP

                            ↳ Rewriting

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Rewriting

                                                      ↳ QDP

                                                        ↳ Rewriting

                                                          ↳ QDP

                                                            ↳ Rewriting

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ Rewriting

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Rewriting

                                                                                          ↳ QDP

                                                                                            ↳ Rewriting

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

                                                                                                      ↳ QDP

                                                                                                        ↳ Rewriting

                                                                                                          ↳ QDP

                                                                                                            ↳ QDPOrderProof

                                                                                                              ↳ QDP

                                                                                                                ↳ QDPOrderProof

                                                                                                                  ↳ QDP

                                                                                                                    ↳ UsableRulesProof

                                                                                                                      ↳ QDP

                                                                                                                        ↳ QReductionProof

                                                                                                                          ↳ QDP

                                                                                                                            ↳ Induction-Processor

                                                                                                                              ↳ AND

                                                                                                                                ↳ QDP

                                                                                                                                ↳ QTRS

                                                                                                                                  ↳ QTRSRRRProof

Q restricted rewrite system:
The TRS R consists of the following rules:

if2'(true, n82, x105, xs61) → true
filterhigh'(n91, cons(x116, xs68)) → if2'(ge(x116, n91), n91, x116, xs68)
if2'(false, n100, x127, xs75) → filterhigh'(n100, xs75)
filterhigh'(n109, nil) → false
ge(x', 0) → true
ge(s(x9), s(y'')) → ge(x9, y'')
if1(true, n14, x20, xs10) → filterlow(n14, xs10)
filterlow(n23, cons(x31, xs17)) → if1(ge(n23, x31), n23, x31, xs17)
if1(false, n32, x42, xs24) → cons(x42, filterlow(n32, xs24))
filterlow(n41, nil) → nil
ge(0, s(x63)) → false
half(0) → 0
half(s(0)) → 0
half(s(s(x94))) → s(half(x94))
if2(true, n82, x105, xs61) → filterhigh(n82, xs61)
filterhigh(n91, cons(x116, xs68)) → if2(ge(x116, n91), n91, x116, xs68)
if2(false, n100, x127, xs75) → cons(x127, filterhigh(n100, xs75))
filterhigh(n109, nil) → nil
equal_bool(true, false) → false
equal_bool(false, true) → false
equal_bool(true, true) → true
equal_bool(false, false) → true
and(true, x) → x
and(false, x) → false
or(true, x) → true
or(false, x) → x
not(false) → true
not(true) → false
isa_true(true) → true
isa_true(false) → false
isa_false(true) → false
isa_false(false) → true
equal_sort[a0](0, 0) → true
equal_sort[a0](0, s(x0)) → false
equal_sort[a0](s(x0), 0) → false
equal_sort[a0](s(x0), s(x1)) → equal_sort[a0](x0, x1)
equal_sort[a5](nil, nil) → true
equal_sort[a5](nil, cons(x0, x1)) → false
equal_sort[a5](cons(x0, x1), nil) → false
equal_sort[a5](cons(x0, x1), cons(x2, x3)) → and(equal_sort[a5](x0, x2), equal_sort[a5](x1, x3))
equal_sort[a67](witness_sort[a67], witness_sort[a67]) → true

Q is empty.

The following Q TRS is given: Q restricted rewrite system:
The TRS R consists of the following rules:

if2'(true, n82, x105, xs61) → true
filterhigh'(n91, cons(x116, xs68)) → if2'(ge(x116, n91), n91, x116, xs68)
if2'(false, n100, x127, xs75) → filterhigh'(n100, xs75)
filterhigh'(n109, nil) → false
ge(x', 0) → true
ge(s(x9), s(y'')) → ge(x9, y'')
if1(true, n14, x20, xs10) → filterlow(n14, xs10)
filterlow(n23, cons(x31, xs17)) → if1(ge(n23, x31), n23, x31, xs17)
if1(false, n32, x42, xs24) → cons(x42, filterlow(n32, xs24))
filterlow(n41, nil) → nil
ge(0, s(x63)) → false
half(0) → 0
half(s(0)) → 0
half(s(s(x94))) → s(half(x94))
if2(true, n82, x105, xs61) → filterhigh(n82, xs61)
filterhigh(n91, cons(x116, xs68)) → if2(ge(x116, n91), n91, x116, xs68)
if2(false, n100, x127, xs75) → cons(x127, filterhigh(n100, xs75))
filterhigh(n109, nil) → nil
equal_bool(true, false) → false
equal_bool(false, true) → false
equal_bool(true, true) → true
equal_bool(false, false) → true
and(true, x) → x
and(false, x) → false
or(true, x) → true
or(false, x) → x
not(false) → true
not(true) → false
isa_true(true) → true
isa_true(false) → false
isa_false(true) → false
isa_false(false) → true
equal_sort[a0](0, 0) → true
equal_sort[a0](0, s(x0)) → false
equal_sort[a0](s(x0), 0) → false
equal_sort[a0](s(x0), s(x1)) → equal_sort[a0](x0, x1)
equal_sort[a5](nil, nil) → true
equal_sort[a5](nil, cons(x0, x1)) → false
equal_sort[a5](cons(x0, x1), nil) → false
equal_sort[a5](cons(x0, x1), cons(x2, x3)) → and(equal_sort[a5](x0, x2), equal_sort[a5](x1, x3))
equal_sort[a67](witness_sort[a67], witness_sort[a67]) → true

Q is empty.
Used ordering:
Combined order from the following AFS and order.
if2'(x1, x2, x3, x4) = if2'(x1, x2, x3, x4)
true = true
filterhigh'(x1, x2) = filterhigh'(x1, x2)
cons(x1, x2) = cons(x1, x2)
ge(x1, x2) = ge(x1, x2)
false = false
nil = nil
0 = 0
s(x1) = x1
if1(x1, x2, x3, x4) = if1(x1, x2, x3, x4)
filterlow(x1, x2) = filterlow(x1, x2)
half(x1) = half(x1)
if2(x1, x2, x3, x4) = if2(x1, x2, x3, x4)
filterhigh(x1, x2) = filterhigh(x1, x2)
equal_bool(x1, x2) = equal_bool(x1, x2)
and(x1, x2) = and(x1, x2)
or(x1, x2) = or(x1, x2)
not(x1) = not(x1)
isa_true(x1) = isa_true(x1)
isa_false(x1) = x1
equal_sort[a0](x1, x2) = equal_sort[a0](x1, x2)
equal_sort[a5](x1, x2) = equal_sort[a5](x1, x2)
equal_sort[a67](x1, x2) = equal_sort[a67](x1, x2)
witness_sort[a67] = witness_sort[a67]

Recursive path order with status [RPO].
Quasi-Precedence:

[if2'₄, filterhigh'₂] > [ge₂, if1₄, filterlow₂] > [true, cons₂, false, nil, 0, isa_true₁, equal_sort[a67]₂, witness_sort[a67]] > and₂
[if2₄, filterhigh₂] > [ge₂, if1₄, filterlow₂] > [true, cons₂, false, nil, 0, isa_true₁, equal_sort[a67]₂, witness_sort[a67]] > and₂
or₂ > [true, cons₂, false, nil, 0, isa_true₁, equal_sort[a67]₂, witness_sort[a67]] > and₂
equal_sort[a0]₂ > [true, cons₂, false, nil, 0, isa_true₁, equal_sort[a67]₂, witness_sort[a67]] > and₂
equal_sort[a5]₂ > [true, cons₂, false, nil, 0, isa_true₁, equal_sort[a67]₂, witness_sort[a67]] > and₂

Status:

if2₄: [4,2,1,3]
true: multiset
filterhigh'₂: [1,2]
filterhigh₂: [2,1]
or₂: multiset
and₂: multiset
if2'₄: [2,4,1,3]
0: multiset
equal_bool₂: multiset
equal_sort[a0]₂: [1,2]
cons₂: multiset
equal_sort[a5]₂: multiset
half₁: [1]
witness_sort[a67]: multiset
not₁: multiset
false: multiset
filterlow₂: [1,2]
equal_sort[a67]₂: multiset
ge₂: [1,2]
nil: multiset
if1₄: [2,4,1,3]
isa_true₁: multiset

With this ordering the following rules can be removed by the rule removal processor [LPAR04] because they are oriented strictly:

if2'(true, n82, x105, xs61) → true
filterhigh'(n91, cons(x116, xs68)) → if2'(ge(x116, n91), n91, x116, xs68)
if2'(false, n100, x127, xs75) → filterhigh'(n100, xs75)
filterhigh'(n109, nil) → false
ge(x', 0) → true
if1(true, n14, x20, xs10) → filterlow(n14, xs10)
filterlow(n23, cons(x31, xs17)) → if1(ge(n23, x31), n23, x31, xs17)
if1(false, n32, x42, xs24) → cons(x42, filterlow(n32, xs24))
filterlow(n41, nil) → nil
ge(0, s(x63)) → false
half(0) → 0
half(s(0)) → 0
if2(true, n82, x105, xs61) → filterhigh(n82, xs61)
filterhigh(n91, cons(x116, xs68)) → if2(ge(x116, n91), n91, x116, xs68)
if2(false, n100, x127, xs75) → cons(x127, filterhigh(n100, xs75))
filterhigh(n109, nil) → nil
equal_bool(true, false) → false
equal_bool(false, true) → false
equal_bool(true, true) → true
equal_bool(false, false) → true
and(true, x) → x
and(false, x) → false
or(true, x) → true
or(false, x) → x
not(false) → true
not(true) → false
isa_true(true) → true
isa_true(false) → false
equal_sort[a0](0, 0) → true
equal_sort[a0](0, s(x0)) → false
equal_sort[a0](s(x0), 0) → false
equal_sort[a5](nil, nil) → true
equal_sort[a5](nil, cons(x0, x1)) → false
equal_sort[a5](cons(x0, x1), nil) → false
equal_sort[a5](cons(x0, x1), cons(x2, x3)) → and(equal_sort[a5](x0, x2), equal_sort[a5](x1, x3))
equal_sort[a67](witness_sort[a67], witness_sort[a67]) → true

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Rewriting

                          ↳ QDP

                            ↳ Rewriting

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Rewriting

                                                      ↳ QDP

                                                        ↳ Rewriting

                                                          ↳ QDP

                                                            ↳ Rewriting

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ Rewriting

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Rewriting

                                                                                          ↳ QDP

                                                                                            ↳ Rewriting

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

                                                                                                      ↳ QDP

                                                                                                        ↳ Rewriting

                                                                                                          ↳ QDP

                                                                                                            ↳ QDPOrderProof

                                                                                                              ↳ QDP

                                                                                                                ↳ QDPOrderProof

                                                                                                                  ↳ QDP

                                                                                                                    ↳ UsableRulesProof

                                                                                                                      ↳ QDP

                                                                                                                        ↳ QReductionProof

                                                                                                                          ↳ QDP

                                                                                                                            ↳ Induction-Processor

                                                                                                                              ↳ AND

                                                                                                                                ↳ QDP

                                                                                                                                ↳ QTRS

                                                                                                                                  ↳ QTRSRRRProof

                                                                                                                                    ↳ QTRS

                                                                                                                                      ↳ QTRSRRRProof

Q restricted rewrite system:
The TRS R consists of the following rules:

ge(s(x9), s(y'')) → ge(x9, y'')
half(s(s(x94))) → s(half(x94))
isa_false(true) → false
isa_false(false) → true
equal_sort[a0](s(x0), s(x1)) → equal_sort[a0](x0, x1)

Q is empty.

The following Q TRS is given: Q restricted rewrite system:
The TRS R consists of the following rules:

ge(s(x9), s(y'')) → ge(x9, y'')
half(s(s(x94))) → s(half(x94))
isa_false(true) → false
isa_false(false) → true
equal_sort[a0](s(x0), s(x1)) → equal_sort[a0](x0, x1)

Q is empty.
Used ordering:
Polynomial interpretation [POLO]:

POL(equal_sort[a0](x₁, x₂)) = x₁ + x₂
POL(false) = 2
POL(ge(x₁, x₂)) = 2·x₁ + x₂
POL(half(x₁)) = 2 + 2·x₁
POL(isa_false(x₁)) = 2 + 2·x₁
POL(s(x₁)) = 1 + 2·x₁
POL(true) = 1

With this ordering the following rules can be removed by the rule removal processor [LPAR04] because they are oriented strictly:

ge(s(x9), s(y'')) → ge(x9, y'')
half(s(s(x94))) → s(half(x94))
isa_false(true) → false
isa_false(false) → true
equal_sort[a0](s(x0), s(x1)) → equal_sort[a0](x0, x1)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Rewriting

                          ↳ QDP

                            ↳ Rewriting

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ Rewriting

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Rewriting

                                                      ↳ QDP

                                                        ↳ Rewriting

                                                          ↳ QDP

                                                            ↳ Rewriting

                                                              ↳ QDP

                                                                ↳ Rewriting

                                                                  ↳ QDP

                                                                    ↳ Narrowing

                                                                      ↳ QDP

                                                                        ↳ Rewriting

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Rewriting

                                                                                          ↳ QDP

                                                                                            ↳ Rewriting

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

                                                                                                      ↳ QDP

                                                                                                        ↳ Rewriting

                                                                                                          ↳ QDP

                                                                                                            ↳ QDPOrderProof

                                                                                                              ↳ QDP

                                                                                                                ↳ QDPOrderProof

                                                                                                                  ↳ QDP

                                                                                                                    ↳ UsableRulesProof

                                                                                                                      ↳ QDP

                                                                                                                        ↳ QReductionProof

                                                                                                                          ↳ QDP

                                                                                                                            ↳ Induction-Processor

                                                                                                                              ↳ AND

                                                                                                                                ↳ QDP

                                                                                                                                ↳ QTRS

                                                                                                                                  ↳ QTRSRRRProof

                                                                                                                                    ↳ QTRS

                                                                                                                                      ↳ QTRSRRRProof

                                                                                                                                        ↳ QTRS

                                                                                                                                          ↳ RisEmptyProof

                                                                                                                                          ↳ RisEmptyProof

                                                                                                                                          ↳ RisEmptyProof